"use strict"; const accounts = require("./accounts.js"); const achievements = require("./achievements.js"); const adopt = require("./adopt.js"); const config = require("../config.js"); const colours = require("./colours.js"); const commandModule = require("./commands.js"); const limits = require("./limits.js"); const masterpieces = require("./masterpieces.js"); const defpacks = require("./defpacks.js"); const avatarHandlers = require("./avatars.js"); const badges = require("./badges.js"); const bans = require("./bans.js"); const chatlog = require("./chatlog.js"); const buddyModule = require("./buddies.js"); const dens = require("./dens.js"); const disguises = require("./disguises.js"); const ecardModule = require("./ecards.js"); const epicDens = require("./epicdens.js"); const itemHandlers = require("./items.js"); const minigameModule = require("./minigames.js"); const adventureModule = require("./adventures.js"); const moderationModule = require("./moderation.js"); const partyModule = require("./parties.js"); const petModule = require("./pets.js"); const reports = require("./reports.js"); const roomInfo = require("./roominfo.js"); const shopStock = require("./shopstock.js"); const signup = require("./signup.js"); const tradeHandlers = require("./trades.js"); const stubHandlers = require("./stubs.js"); const wallModule = require("./walls.js"); const worldItems = require("./worlditems.js"); const {CURRENCIES, DIAMOND_TYPES, activeAvatar, avatarById, activePet, equippedBits, wornItems, lastSeenField} = require("./player.js"); // game logic behind the socket. field orders below mirror the client's // parsers; the class that reads each message is named next to it. const GENERIC_LIST_AVATARS = 64; const GENERIC_LIST_NEWSPAPER = 627; const USER_VAR_NEWSPAPER_READ = 455; const USER_VAR_GEM_BONUS = 214; // not one of the game's: the patched client's "hide blocked players" setting // (gui.MySettings), kept with the user vars so it reaches the client at login. const USER_VAR_HIDE_BLOCKED = 9001; // "Graphics" in the game's settings menu: 1 Default (smooth graphics off), // 2 Smooth, unset for the server's default (config.smooth). const USER_VAR_GRAPHICS = 9003; const GENERIC_LIST_WORLD_ITEMS = 583; const DEF_PET_FOOD = 1062; const DEF_PET_TOY = 1063; // the two exchange counters: gems for tickets (114), diamonds for gems (169). const CURRENCY_GEMS = 0; const CURRENCY_DIAMONDS = 3; const EXCHANGE_LIST_PAID_WITH = new Map([[114, CURRENCY_GEMS], [169, CURRENCY_DIAMONDS]]); // the phrase menus ("safe chat": SafeChatManager) of the chat bar (47), // Jam-A-Grams and reports (66), the photo booth (158), adventures (170) and // Jammer Walls (333). an entry is the id of a localization string holding // one menu, a phrase to a line; when the first line ends in "..." the rest // complete it. which menus each list had is not in any file; these are the // game's own menu strings, sorted by what they are evidently for. the lists // must not be empty: the Jam-A-Gram window reads the first phrase of 66. const range = (first, last) => Array.from({length: last - first + 1}, (_, i) => first + i); const DEF_NAMEBAR_BADGE = 1049; const GENERIC_LIST_GAMES = 341; // GameJoinPopup: game def ids const SAFE_CHAT_LISTS = new Map([ [47, [36, 22, 23, 24, 25, 33, 26, 30, 29, 31, 32, 34, 35, 28]], [66, [1759, 1760, 1769, 1758, 1761, 1762, 1763, 1764, 1765, 1768, 1767, 1770, 1771, 3126, 1766]], [158, [36, 26, 33]], [170, [...range(3549, 3556), ...range(3585, 3592)]], [333, [27, 36, 25, 33, 26, 28]], ]); // the client shows a cut-down party list to accounts less than a day old // (PartyPopup) and a "refer a friend" button to ones older than three // (BuddyList). neither is wanted, so every account says it is two days old. const ACCOUNT_AGE_SHOWN_SECONDS = 2 * 86400; const MOTD_SETTING = "motd"; const MAX_ANNOUNCEMENT = 300; const RECENT_CHAT_LINES = 15; // bit flags for tutorials already seen: the den editor's and den shop's // talking prompts (379) and the trade list help boxes (129). every bit is kept // set so none of them ever shows. for these two the client sends the number // of the bit to set, not a new value (UserVarCache.isBitSet). const USER_VAR_DEN_TUTORIAL = 379; const USER_VAR_TRADE_TUTORIAL = 129; const TUTORIALS_ALL_SEEN = 65535; const BIT_FLAG_VARS = [USER_VAR_DEN_TUTORIAL, USER_VAR_TRADE_TUTORIAL]; const GEM_BONUS_NEVER_DUE = 65535; // pets the pet picker must not offer (PetCreator.onNotViewablePetDefsLoaded); none here. const GENERIC_LIST_HIDDEN_PETS = 574; // word lists for the animal (first, second, third word) and pet (first, // second) name pickers. entries are localization string ids; the id ranges // were read off the English localization defPack, where each list sits in one // alphabetical block. const NAME_LISTS = new Map([ [200, [15136, 15223]], [202, [15224, 15298]], [203, [15299, 15385]], [205, [15386, 15427]], [206, [15428, 15475]], ]); const DEF_ITEM = 1000; const DEF_PET = 1046; const DEF_DEN_ITEM = 1030; const DEF_COMBINED_LIST = 1060; const DEF_DEN_ROOM = 1040; const DEF_CURRENCY_EXCHANGE = 1051; const DEF_DIAMOND = 1054; const SHOP_LIST_TYPES = [DEF_ITEM, DEF_DEN_ITEM, DEF_DEN_ROOM, DEF_COMBINED_LIST, DEF_CURRENCY_EXCHANGE, DEF_DIAMOND]; // diamond lists the client reads at login to learn which animals and pets // cost diamonds. they stay empty: animals and pets are free here. const DIAMOND_ANIMAL_AND_PET_LISTS = [166, 214, 293]; // the Diamond Shop's two den displays ("one" and "two" in its room file). // taken for the dens sold for diamonds: nothing else in the room is. const DIAMOND_DEN_LIST = 196; const LANG_ENG = 0; const IDLE_ANIM_LAND = 14; const IDLE_ANIM_OCEAN = 29; const MAX_PATH_POINTS = 12; const TYPED_NAME = /^[A-Za-z0-9][A-Za-z0-9 '.-]{0,19}$/; // an animal's or pet's name typed by its owner const MAX_BLOCKED = 1000; // from the account page; the game's own button has no limit const TYPED_CHAT_TYPES = ["0", "9"]; const MAX_CHAT_EXTRA = 100; // the field after a chat line's type const MAX_USER_VARS = 2000; const MAX_FILTER_WORDS = 100; // a player's own words for their chat filter const MAX_FILTER_WORD = 30; const LOGIN_BANNED = -15; // MainFrame.MSG_ID_LOGIN_BANNED const THEME_PATH_PREFIX = "theme_"; // lib/http.js looks for this const chatLines = limits.limiter(config.chatLinesPerWindow, config.chatWindowMs); const online = new Map(); // lowercased username -> session const rooms = new Map(); // "path.name#shard" -> room let nextRoomId = 100; const others = session => session.room ? [...session.room.sessions].filter(s => s !== session) : []; // blocking. A player who blocked another never gets their chat, cannot be // visited, written to or joined by them; with their "hide blocked players" // setting on, they do not get that player's animal drawn at all. const nameKey = account => account.username.toLowerCase(); const blocks = { has: (blocker, target) => blocker.blocked.includes(nameKey(target)), either: (a, b) => a.blocked.includes(nameKey(b)) || b.blocked.includes(nameKey(a)), }; const sees = (viewer, subject) => !(viewer.account.hideBlocked && blocks.has(viewer.account, subject.account)); // everyone else in the room who should hear about this player's animal. const watchers = session => others(session).filter(other => sees(other, session)); const decodeEntities = text => text .replace(/</g, "<") .replace(/>/g, ">") .replace(/'/g, "'") .replace(/"/g, '"') .replace(/&/g, "&"); // GamePlay.onWorldLogIn const loginParams = session => { const {account} = session; const params = { userId: session.id, userName: account.username, dbUserId: account.id, uuid: account.uuid, accountType: account.accountType, accountTypeChanged: false, avName: activeAvatar(account).name, perUserAvId: activeAvatar(account).perUserAvId, activeDenRoomInvId: account.activeDen, activePetInvId: activeAvatar(account).petInvId, createdAt: Math.floor(Date.now() / 1000) - ACCOUNT_AGE_SHOWN_SECONDS, numLogins: account.numLogins, sessionId: session.id, jamaaDate: Math.floor(Date.now() / 86400000), // bit 0: tutorial finished, and what most name tag badges ask for. bit 2 // unlocks the one badge that asks for more (defPack 1049, // pendingFlagsBit). bit 4 would force the "fast pass" avatar flow. // bit 1 is the "extended inventory" (more den items placed, bigger // inventories); the patched client counts to 5,000 of each either way // (shop.ShopManager). // from bit 8 up: the name tag badges the admin gave this account // (lib/badges.js). pendingFlags: 7 | badges.loginFlags(account), dailyGiftIndex: -1, hasOnlineBuddies: buddies.hasOnlineBuddies(account), // one bit per kind of interaction (Utility.canBuddy, canTrade, canGift, // canChat, ...); everything is allowed. interactions: 1023, isGuide: account.isGuide, isModerator: account.isModerator, userNameModerated: 1, sgChatType: 1, sgChatTypeNonDegraded: 1, denPrivacySettings: account.denPrivacy, playerWallSettings: account.wall.privacy, // not 0: PlayerWallManager only opens walls for accounts with them on. webWallStatus: 1, eCardPrivacySettings: account.ecardPrivacy, // not empty: with neither address set, every fifth login opens a // "parent's email" window (GuiManager.showAjEmailBtn). accounts here // have no email. email: "-", pendingEmail: "", lastBroadcastMessage: "", numAJHQGiftCards: 0, numAJHQBulkGiftCards: 0, numRedemptionCards: ecards.redemptions(account), numUnreadECards: ecards.unread(account), numDaysLeftOnSubscription: account.membershipDays, subscriptionSourceType: 0, recyclePercentage: 0.3, usableAdoptAPetDefs: adopt.loginList(account), newspaperDefs: [], }; for (const name of CURRENCIES) { account.currency[name] = Math.max(account.currency[name] || 0, config.minimumCurrency); params[`${name}Count`] = account.currency[name]; } return params; }; const loginFailed = (session, statusId, message) => { session.sendXtJson(-1, {_cmd: "login", status: "0", statusId, message, params: {}}); }; // SmartFoxClient.login: nick is "username%sessionId%language%deployVersion% // platform%platformVersion%os%df" and pword is the auth token. const login = (session, msg) => { if (new RegExp(``).test(msg.raw)) { // guest login for the Create Account screens (SysHandler.handleLoginOk). session.signingUp = true; session.sendSys("logOK", 0, ``); return; } // one login to a socket: a second would leave the first account looking online. if (session.account) { session.close(); return; } const username = (msg.cdata("nick") || "").split("%")[0]; const account = accounts.byToken(msg.cdata("pword")); if (!account || account.username.toLowerCase() !== username.toLowerCase()) { console.log(`[world] login rejected for "${username}"`); loginFailed(session, 0, "Invalid login"); return; } if (moderation.banRemaining(account) !== 0) { console.log(`[world] login rejected for banned account "${account.username}"`); loginFailed(session, LOGIN_BANNED, "Banned"); return; } // A banned address (lib/bans.js). the client is told at /authenticate, // with the reason; this is for a game that got here another way. if (bans.addressBan(session.address)) { console.log(`[world] login rejected for "${account.username}" from a banned address`); loginFailed(session, LOGIN_BANNED, "Banned"); return; } // its username was rejected (lib/moderation.js): a new one first, which // the client or the account page asks for. if (account.nameRejected) { console.log(`[world] login rejected for "${account.username}": the name was rejected`); loginFailed(session, 0, "Username rejected"); return; } // locked by its owner on the account page (lib/manage.js). if (account.locked) { console.log(`[world] login rejected for locked account "${account.username}"`); loginFailed(session, 0, "Account locked"); return; } const key = account.username.toLowerCase(); const existing = online.get(key); if (existing && existing !== session) { existing.close(); leaveWorld(existing); } session.account = account; account.numLogins++; accounts.recordLogin(account, "game", session.address); account.lastLogin = Math.floor(Date.now() / 1000); session.recentChat = []; session.greeted = false; session.arrived = false; // not yet put in a first room if (account.randomTheme) { const names = Object.keys(config.themes); account.theme = names[Math.floor(Math.random() * names.length)]; } account.pets.forEach(pets.giveCharacter); adopt.dailyFind(account); // before the session is findable, so that nothing is sent ahead of the // login reply. achievements.refresh(account); accounts.save(); online.set(key, session); console.log(`[world] ${account.username} logged in as sfs user ${session.id}`); session.sendXtJson(-1, {_cmd: "login", status: "1", params: loginParams(session)}); // every custom colour, before anything that might be drawn with one // (XtReplyDemuxer -> PaletteHelper.handleCustomColors in the patched SWF). for (const chunk of colours.chunks()) { session.sendXt("xcc", -1, chunk.length, ...chunk.flat()); } sendFilter(session); buddies.announce(account); }; // ItemXtCommManager.itemListResponse ("0": everything the player owns, five // fields per item) / itemsInUseResponse ("1": what one animal is wearing, // three fields per item). both start with the animal's eyes and pattern. const sendItemList = (to, target, full, perUserAvId) => { const {account} = target; const avatar = avatarById(account, perUserAvId); const items = full ? account.items.flatMap(item => [item.def, item.inv, item.color, equippedBits(item), 0]) : wornItems(account, avatar).flatMap(item => [item.def, item.inv, item.color]); const count = full ? account.items.length : wornItems(account, avatar).length; to.sendXt("il", -1, full ? "0" : "1", 0, avatar.perUserAvId, account.username, avatar.eyes, avatar.pattern, count, ...items); }; // lBits, uBits, eBits, name, createdTs, personality, favourite toy, favourite food const petFields = pet => pet ? [pet.lBits, pet.uBits, pet.eBits, pet.name, pet.createdAt, pet.personality || 0, pet.toy || 0, pet.food || 0] : [0, 0, 0, "", 0, 0, 0, 0]; // AvatarXtCommManager.avatarDataResponse const sendAvatarData = (to, target, perUserAvId) => { const {account} = target; const avatar = avatarById(account, perUserAvId); const enviroType = target.room ? target.room.enviroType : 0; const head = [ account.username, account.uuid, account.nameBarData, enviroType, 1, // userNameModeratedFlag parties.timeLeft(account), // timeLeftHostingCustomParty lastSeenField(account, Boolean(findOnline(account.username))), // daysSinceLastLogin: see lib/player.js avatar.perUserAvId, avatar.type, avatar.customAvId, ...avatar.colors, avatar.name, avatar.questLevel || 0, // the admin sets it: setQuestLevel ]; const tail = to === target // avInvId, landPetInvId, oceanPetInvId, attackBase, attackMax, defenseBase, defenseMax, healthBase ? [avatar.avInvId, avatar.petInvId, avatar.petInvId, 0, 0, 0, 0, 100] // pet lBits, uBits, eBits, name : petFields(activePet(account)).slice(0, 4); to.sendXt("ad", -1, ...head, ...tail); }; // AvatarManager.avatarCreateResponse: puts `target` on `to`'s screen. const sendAvatarCreate = (to, target) => { const {account, room} = target; const avatar = activeAvatar(account); const pet = activePet(account); to.sendXt("ac", room.id, target.id, target.pos.x, target.pos.y, room.enviroType === 0 ? IDLE_ANIM_LAND : IDLE_ANIM_OCEAN, account.username, account.uuid, avatar.perUserAvId, avatar.name, avatar.type, avatar.customAvId, ...avatar.colors, avatar.questLevel || 0, 1, // userNameModeratedFlag lastSeenField(account, Boolean(findOnline(account.username))), // daysSinceLastLogin: see lib/player.js // optional-field flags: bit 0 accountType, bit 1 nameBarData, bit 2 pet pet ? 7 : 3, account.accountType, account.nameBarData, ...(pet ? petFields(pet) : [])); sendItemList(to, target, false); disguises.show(to, target); }; // redraws `session`'s animal for everyone else in the room, for changes the // protocol has no dedicated broadcast for (colours). const refreshForOthers = session => { if (!session.pos) { return; } for (const other of watchers(session)) { other.sendXt("ar", session.room.id, session.id); sendAvatarCreate(other, session); } }; const denRoomsForSale = () => defpacks.denRoomIds().filter(id => defpacks.denRoomName(id)); // the Summer Carnival's three shops sell what is priced in tickets, and // nobody else does: clothing, den items, and the plushie stand. const CURRENCY_TYPE_TICKETS = "1"; const TICKET_SHOPS = new Map([[101, "clothing"], [165, "denItems"], [102, "plushies"]]); let stock = null; const sortStock = () => { if (!stock) { const forTickets = def => def.currencyType === CURRENCY_TYPE_TICKETS; const clothing = defpacks.clothingIds(); const denItems = defpacks.denItemIds().filter(id => !defpacks.unsoldDenItemIds().includes(id)); const ticketDenItems = denItems.filter(id => forTickets(defpacks.denItemDef(id))); const isPlushie = id => /plush/i.test(defpacks.denItemDef(id).abbrName); stock = { clothing: clothing.filter(id => forTickets(defpacks.itemDef(id))), denItems: ticketDenItems.filter(id => !isPlushie(id)), plushies: ticketDenItems.filter(isPlushie), }; } return stock; }; // two out-of-the-way shops keep what was never in one: the shop in the // Chamber of Knowledge's base (reached from a hidden spot on the world map) // has the den items, the one in the Zios archives the clothing. see // oddDenItemIds in lib/defpacks.js. const ODDITY_SHOPS = new Map([[396, () => defpacks.oddDenItemIds()], [666, () => defpacks.oddClothingIds()]]); const ticketStock = kind => sortStock()[kind]; // the den shops of the lands (Coral Canyons, Deep Blue) and the one inside // a den: lists that mix kinds, selling den rooms. const DEN_SHOP_LISTS = [213, 375, 384]; // AchievementXtCommManager.getUserVarsResponse: [count, (varId, type, value)...] const sendUserVars = session => { const vars = session.account.userVars; // there is no newspaper on this server; a "last read" time stops the // client opening an empty one at every login (NewspaperManager). if (vars[USER_VAR_NEWSPAPER_READ] === undefined) { vars[USER_VAR_NEWSPAPER_READ] = Math.floor(Date.now() / 1000); } // likewise the daily gem-bonus wheel: GuiManager.guiStartupChecks spins it // when the low 16 bits of this var (the day it was last spun) are before // today's jamaaDate. the far-future day keeps it shut. vars[USER_VAR_GEM_BONUS] = GEM_BONUS_NEVER_DUE; vars[USER_VAR_DEN_TUTORIAL] = TUTORIALS_ALL_SEEN; vars[USER_VAR_TRADE_TUTORIAL] = TUTORIALS_ALL_SEEN; vars[USER_VAR_HIDE_BLOCKED] = session.account.hideBlocked ? 1 : 0; const entries = Object.entries(vars); // smooth graphics off by default: told to the client as "Graphics: // default", and kept nowhere, so the default can change back. if (!config.smooth && !(Number(vars[USER_VAR_GRAPHICS]) > 0)) { entries.push([String(USER_VAR_GRAPHICS), 1]); } session.sendXt("zg", -1, entries.length, ...entries.flatMap(([id, value]) => [id, 0, value])); }; const findOnline = username => online.get(String(username).toLowerCase()); // the account's chat filter, for its game to apply: [chosen, level, mode, own words]. const sendFilter = session => { const {filter} = session.account; session.sendXt("xfl", -1, filter.chosen ? 1 : 0, filter.level, filter.mode, filter.words); }; // the player called `username` as the senders above take one: their session // when they are playing, else just their account. A player's card can be // opened for anybody (the buddy list, the player search), and it asks for // their animals and what those wear whether or not they are in the game. const findPlayer = username => { const account = accounts.byName(username); return findOnline(username) || (account ? {account, room: null} : null); }; const handlers = { // KeepAlive: no reply expected. ka() {}, // the chat filter's window in the patched client (AJClient.saveChatFilter): // [level, mode, the player's own words with commas between]. kept with // the account and sent back, which is what takes effect in their game. // the filtering is all theirs: nothing here reads chat for it. xfl(session, roomId, [level, mode, ...words]) { const own = words.join(",").split(/[\s,]+/).map(word => word.replace(/[^\p{L}\p{N}@$*'-]/gu, "").slice(0, MAX_FILTER_WORD)) .filter(Boolean).slice(0, MAX_FILTER_WORDS); session.account.filter = {level: [0, 1, 2].includes(Number(level)) ? Number(level) : 0, mode: Number(mode) === 1 ? 1 : 0, words: [...new Set(own)].join(","), chosen: true}; accounts.save(); sendFilter(session); }, // the patched client's hex colour picker (gui.ColorTable): [rgb1, rgb2, // rgb3, rgb4], the four colours of one layer. everyone online is told the // entry's id, the asker included, who then uses it as that layer's colour. // A colour somebody made before is anybody's to use; a new one counts // against the day's allowance of whoever asks (config.customColoursPerDay). xcc(session, roomId, params) { const {account} = session; const today = Math.floor(Date.now() / 86400000); const made = account.coloursMade && account.coloursMade.day === today ? account.coloursMade.count : 0; const entry = colours.allocate(params.slice(0, 4).map(Number), made < config.customColoursPerDay); if (!entry) { return; } if (entry.full) { tell(session, "No more new colours today. Colours made before can still be used."); return; } if (entry.created) { account.coloursMade = {day: today, count: made + 1}; accounts.save(); } for (const recipient of entry.created ? online.values() : [session]) { recipient.sendXt("xcc", -1, 1, entry.id, ...entry.rgbs); } }, // AvatarXtCommManager.avatarListResponse. the animal in use is listed first. al(session, roomId, [username]) { const target = findPlayer(username); if (!target) { session.sendXt("al", -1, username, 0); return; } const {account} = target; const active = activeAvatar(account); const avatars = [active, ...account.avatars.filter(avatar => avatar !== active)]; if (target === session) { // 0xFFFFFFFF marks every avatar slot as available (AvatarSwitch.availSlotFlags). session.sendXt("al", -1, account.username, 4294967295, account.uuid, avatars.length, ...avatars.flatMap(avatar => [avatar.perUserAvId, avatar.avInvId, avatar.name, avatar.type, avatar.customAvId])); } else { session.sendXt("al", -1, account.username, avatars.length, ...avatars.map(avatar => avatar.perUserAvId)); } }, // [username, perUserAvId, "0" no items | "1" full item list | "2" items in use] ad(session, roomId, [username, perUserAvId, itemFlag]) { const target = findPlayer(username); if (!target) { return; } sendAvatarData(session, target, perUserAvId); if (itemFlag === "1" || itemFlag === "2") { sendItemList(session, target, itemFlag === "1" && target === session, perUserAvId); } }, // [username, perUserAvId, "1" full list | "0" items in use] il(session, roomId, [username, perUserAvId, full]) { const target = findPlayer(username); if (target) { sendItemList(session, target, full === "1" && target === session, perUserAvId); } }, // AvatarManager.processQueuedPositions / updateAvatar: // [count, x1, y1, ..., animAndFlip, teleport] au(session, roomId, params) { if (!session.room) { return; } const count = Number(params[0]); const coords = params.slice(1, 1 + count * 2).map(Number); if (!Number.isInteger(count) || count < 1 || count > MAX_PATH_POINTS || coords.length !== count * 2 || !coords.every(Number.isInteger)) { return; } const teleport = params[params.length - 1] === "1" ? 1 : 0; const firstUpdate = !session.pos; session.pos = {x: coords[coords.length - 2], y: coords[coords.length - 1]}; if (!session.greeted) { // the first room has loaded: the client can show a popup now. session.greeted = true; const motd = accounts.setting(MOTD_SETTING); if (motd) { tell(session, motd); } buddies.greet(session); minigames.greet(session); // never asked what chat they want filtered: the window is put to // them, this once (the patched client's "xfa"). if (!session.account.filter.chosen) { session.sendXt("xfa", -1, 1); } } if (firstUpdate) { // the player's own animal is on their screen now: its disguise, if any. disguises.show(session, session); } for (const other of watchers(session)) { if (firstUpdate) { // nobody could see this avatar until it reported where it spawned. sendAvatarCreate(other, session); } else { // AvatarManager.avatarUpdateResponse other.sendXt("au", session.room.id, 1, session.id, count, ...coords, teleport); } } }, // GenericListXtCommManager.handleNewData: [listId, entryType, 4 unused // fields, count, ...entries]. the entry type comes from the list-type // defPack. list contents live on the official servers, so apart from the two // kinds that can be rebuilt from defPacks every list is answered empty; that // still releases whatever the client had waiting on it. gl(session, roomId, [listId]) { if (Number(listId) === GENERIC_LIST_NEWSPAPER) { // the client decides whether to pop the newspaper open when this list // arrives, from the "last read" user var, so its saved vars must get // there first. it never asks for them; the server pushes them. sendUserVars(session); } const type = defpacks.listType(listId); if (type === undefined) { unhandled("gl", [listId]); return; } let entries = []; let count; if (Number(listId) === GENERIC_LIST_AVATARS) { entries = defpacks.avatarTypes(); } else if (defpacks.patternList(listId)) { entries = defpacks.patternList(listId); } else if (parties.list(listId)) { // the hosted-party window: party rooms, its three name wheels, music. entries = parties.list(listId); } else if (ecards.list(listId)) { // Jam-A-Gram cards or stamps, as (mediaId, name) pairs. entries = ecards.list(listId); count = entries.length / 2; } else if (Number(listId) === pets.PERSONALITY_LIST) { entries = pets.personalityList(); } else if (type === DEF_PET_FOOD || type === DEF_PET_TOY) { // what a kind of pet may favour, as (defId, name string id) pairs. entries = pets.favouritesList(type, listId); count = entries.length / 2; } else if (type === DEF_CURRENCY_EXCHANGE) { const paidWith = EXCHANGE_LIST_PAID_WITH.get(Number(listId)); entries = defpacks.exchangeDefs().filter(def => paidWith === undefined || def.costType === paidWith).map(def => def.id); } else if (Number(listId) === GENERIC_LIST_WORLD_ITEMS) { entries = worldItems.usable(session.account); } else if (type === DEF_NAMEBAR_BADGE) { // every badge, in id order: a name tag names its badge by its place // in this list (NameBar.setBadgeIcon). entries = defpacks.badgeIds(); } else if (Number(listId) === GENERIC_LIST_GAMES) { entries = minigames.library(); } else if (adventures.list(listId)) { entries = adventures.list(listId); } else if (masterpieces.frameList(listId)) { // the frames a painting can be given, as (mediaId, name) pairs. entries = masterpieces.frameList(listId); count = entries.length / 2; } else if (SAFE_CHAT_LISTS.has(Number(listId))) { entries = SAFE_CHAT_LISTS.get(Number(listId)); } else if (walls.list(listId)) { // wallpapers and stickers, as (mediaId, name) pairs. entries = walls.list(listId); count = entries.length / 2; } else if (NAME_LISTS.has(Number(listId))) { const [first, last] = NAME_LISTS.get(Number(listId)); entries = Array.from({length: last - first + 1}, (_, i) => first + i); } else if (TICKET_SHOPS.has(Number(listId))) { entries = ticketStock(TICKET_SHOPS.get(Number(listId))); } else if (ODDITY_SHOPS.has(Number(listId))) { // what the shop really sold comes first. const real = shopStock.list(listId, type); entries = [...new Set([...(real ? real.entries : []), ...ODDITY_SHOPS.get(Number(listId))()])]; } else if (Number(listId) === DIAMOND_DEN_LIST) { entries = defpacks.diamondIds().filter(id => { const def = defpacks.diamondDef(id); return def.type === DIAMOND_TYPES.denRoom && denRoomsForSale().includes(Number(def.refId)); }); } else if (shopStock.list(listId, type)) { // A shop whose shelves the AJ Classic Wiki records: lib/shopstock.js. ({entries, count} = shopStock.list(listId, type)); } else if (type === DEF_DEN_ROOM) { // every den shop sells every den room. entries = denRoomsForSale(); } else if (type === DEF_COMBINED_LIST) { // A shop mixing kinds of item: [kinds, count per kind, entries of // each kind in turn] (ItemXtCommManager.setupShopItemObject). the den // shops get every den room. any other is a shop nothing is known of, // and gets one kind with nothing in it: a reply with no kinds at all // would leave the shop on its loading spinner for good. const rooms = DEN_SHOP_LISTS.includes(Number(listId)) ? denRoomsForSale() : []; count = Math.max(rooms.length, 1); entries = rooms.length > 0 ? [DEF_DEN_ROOM, rooms.length, ...rooms] : [DEF_DEN_ITEM, 0]; } // A clothing, den item or diamond shop that gets here is one no record // was found of. its shelves are empty: the owner would have that // rather than things it never sold. else if (type === DEF_PET && Number(listId) !== GENERIC_LIST_HIDDEN_PETS) { // GenericListXtCommManager.handlePetResponse: (petDefId, available) pairs count = defpacks.petIds().length; entries = defpacks.petIds().flatMap(id => [id, 1]); } // for shops the first unused field is the title's string id; left empty // it keeps the shop window's own title (Shop.gotItemListCallback). const title = SHOP_LIST_TYPES.includes(type) ? (session.room ? roomInfo.shopTitle(session.room.base, listId) : "") : 0; session.sendXt("gl", -1, listId, type, title, 0, 0, 0, count === undefined ? entries.length : count, ...entries); }, // DenXtCommManager.requestDenJoinFull: ["den", confirmLanguage, ?] dj(session, roomId, [roomName]) { joinDen(session, String(roomName)); }, // AchievementXtCommManager.requestSetUserVar: [varId, value, ?]. the reply // (setUserVarResponse) is [varId, value, newAchievementCount]. zs(session, roomId, [id, value]) { if (!/^\d{1,4}$/.test(id) || !Number.isFinite(Number(value))) { return; } const {account} = session; const vars = account.userVars; // the game's own vars and this server's are all below 10,000, and there // are a few hundred of them: an account does not get to keep more. if (vars[id] === undefined && Object.keys(vars).length >= MAX_USER_VARS) { return; } if (Number(id) === USER_VAR_HIDE_BLOCKED) { setHideBlocked(session, Number(value) === 1); } else if (BIT_FLAG_VARS.includes(Number(id))) { vars[id] = TUTORIALS_ALL_SEEN; } else if (achievements.counts(id)) { // A var that achievements count in: the games report "one more" as 1 // and a best score as the score, and the official server knew which // each var was. here 1 adds one and anything else only ever raises it. const current = Number(vars[id]) || 0; vars[id] = Number(value) === 1 ? current + 1 : Math.max(current, Number(value)); } else if (!achievements.SERVER_VARS.has(Number(id))) { // the counters the server keeps itself are not the client's to set. vars[id] = Number(value); } if (vars[id] === undefined) { vars[id] = 0; } const earned = achievements.award(account, id); accounts.save(); achievements.sendVar(session, id, earned); }, zg(session) { sendUserVars(session); }, // ReportAPlayer -> FacilitatorXtCommManager: [username, reasonId]. the // reply (facilitatorReportAPlayerResponse) is [success]. fr(session, roomId, [username, reason]) { session.sendXt("fr", -1, fileReport(session, username, reason) ? 1 : 0); }, // the same about a wall post or a Jam-A-Gram: [username, reasonId, what // (7 wall post, 8 Jam-A-Gram), the post or message]. fra(session, roomId, [username, reason, what, ...data]) { const about = `${what === "7" ? "Jammer Wall post" : "Jam-A-Gram"}: ${data.join("%")}`; session.sendXt("fra", -1, fileReport(session, username, reason, "", about) ? 1 : 0); }, // the patched report window (gui.ReportAPlayer), just before its "fr" or // "fra": [username, reasonId, what the reporter typed]. xrd(session, roomId, [username, reason, ...text]) { fileReport(session, username, reason, text.join("%")); }, // the answer to a yes-or-no box this server put up (ask, below): [id, "1" yes | "0" no]. xyn(session, roomId, [id, answer]) { const asked = session.asked; session.asked = null; if (asked && asked.id === Number(id) && answer === "1") { asked.run(); } }, // A new name typed over an animal's or a pet's in the patched switcher // windows (gui.AvatarSwitcher, gui.PetInventory): ["a", perUserAvId, name] // or ["p", petInvIdx, name]. the reply is [kind, id, "1" | "0", name as it // now is]. A typed name is shown as it is; the game's own are word ids. xrn(session, roomId, [kind, id, ...words]) { const {account} = session; const wanted = words.join(" ").trim(); const thing = kind === "a" ? account.avatars.find(avatar => avatar.perUserAvId === Number(id)) : kind === "p" ? account.pets.find(pet => pet.inv === Number(id)) : null; // typed words others read: not while silenced. const ok = Boolean(thing) && TYPED_NAME.test(wanted) && !moderation.isSilenced(account); if (ok) { thing.name = wanted; accounts.save(); if (kind === "a" && thing === activeAvatar(account)) { sendAvatarData(session, session, thing.perUserAvId); } if (thing === activeAvatar(account) || thing === activePet(account)) { refreshForOthers(session); } } session.sendXt("xrn", -1, kind, id, ok ? 1 : 0, thing ? thing.name : ""); }, // the patched player card (buddy.BuddyCard) asks whether the player it // shows is banned: [username]. the reply starts [username, seconds of ban // left | -1 permanent | 0 not banned], and the card draws a red "Banned" // label from it. xbn(session, roomId, [username]) { const account = accounts.byName(String(username)); if (account) { // ... then when the account was made, for the card's "Joined" label, // their Discord username and their badges ("id|label,id|label"), for // the icons after the name, and their bio, for the Bio tab // (lib/badges.js). session.sendXt("xbn", -1, account.username, moderation.banRemaining(account), account.createdAt, account.discord, badges.cardField(account), account.bio); } }, // VolumeSelector.handleRoomCountResponse: the head-count shown on each land // of the world map, as [count, (roomName, players)...]. rc(session) { // the lands and their shops, as the map shows them: not dens, parties, // or anybody's adventure, whose names are nobody else's business. const counts = [...rooms.values()].filter(room => !room.denOwner && room.roomType === 0).flatMap(room => [room.name, room.sessions.size]); session.sendXt("rc", -1, counts.length / 2, ...counts); }, // RoomXtCommManager.sendRoomJoinRequestFull: [nameOrId, confirmLanguage, invisible, joinType] rj(session, roomId, [roomName]) { joinRoom(session, String(roomName)); }, }; const findBySfsId = id => [...online.values()].find(session => session.id === id); // an "Animal Jam HQ" popup, also kept in the chat history // (UserCommXtCommManager.userCommAdminMessageResponse). the text travels // where a room id usually does; the 1 marks a system message. const tell = (session, text) => session.sendXt("ua", String(text).slice(0, MAX_ANNOUNCEMENT), 1); // puts a yes-or-no box in front of the player ("xyn", shown by the patched // client) and runs `run` if they say yes. one question waits at a time. let nextQuestion = 1; const ask = (session, text, run) => { session.asked = {id: nextQuestion++, run}; session.sendXt("xyn", -1, session.asked.id, String(text).replace(/%/g, " percent")); }; // files a report by this player; false when it was not taken. const fileReport = (session, username, reason, detail = "", about = "") => { // A secret valentine is reported under the name the game showed for it. const target = username === ecards.SECRET_NAME ? ecards.secretSender(session.account) : accounts.byName(username); if (!target || target === session.account) { return false; } const targetSession = findOnline(target.username); const said = targetSession ? targetSession.recentChat.join("\n") : ""; return reports.file({ reporter: session.account.username, target: target.username, reason: Number(reason), detail, context: [about, said].filter(Boolean).join("\n"), room: session.room ? session.room.name : "", }); }; // what the modules below may use of this one. `others` here is everyone who // should see the player's animal change; dens get everyone in the room. const context = { others: watchers, watchers, findOnline, findBySfsId, sendItemList, sendAvatarCreate, refreshForOthers, petFields, blocks, players: () => [...online.values()], enterRoom: (...args) => enterRoom(...args), setHideBlocked: (...args) => setHideBlocked(...args), onBlocked: (...args) => onBlocked(...args), onUnblocked: (...args) => onUnblocked(...args), partyTimeLeft: account => parties.timeLeft(account), tell: (...args) => tell(...args), leaveRoom: (...args) => leaveRoom(...args), ask: (...args) => ask(...args), travel: (session, base) => joinRoom(session, `${base}#${config.shards[0].id}`), joinRoom: (...args) => joinRoom(...args), reloadRoom: session => reloadRoom(session), buyAgain: session => handlers[session.lastPurchase.cmd](session, session.lastPurchase.roomId, session.lastPurchase.params), }; const pets = petModule(context); const parties = partyModule(context); const ecards = ecardModule(context); const walls = wallModule(context); const commands = commandModule(context); const minigames = minigameModule(context); const adventures = adventureModule(context); const buddies = buddyModule(context); const moderation = moderationModule(context); const trades = tradeHandlers(context); achievements.setFinder(findOnline); Object.assign(handlers, avatarHandlers(context), itemHandlers(context), pets.handlers, dens.handlers({...context, others}), buddies.handlers, moderation.handlers, trades.handlers, achievements.handlers, adopt.handlers, worldItems.handlers, parties.handlers, ecards.handlers, walls.handlers, minigames.handlers, adventures.handlers, stubHandlers); const leaveRoom = session => { const {room} = session; if (!room) { return; } room.sessions.delete(session); session.room = null; session.pos = null; for (const other of room.sessions) { // AvatarManager.avatarRemoveResponse if (sees(other, session)) { other.sendXt("ar", room.id, session.id); } } if (room.sessions.size === 0) { rooms.delete(room.name); } }; const leaveWorld = session => { minigames.leave(session); trades.forget(session); leaveRoom(session); if (session.account && online.get(session.account.username.toLowerCase()) === session) { online.delete(session.account.username.toLowerCase()); session.account.lastSeen = Math.floor(Date.now() / 1000); accounts.save(); buddies.announce(session.account); } }; // A room that has another version of itself on the CDN which nothing leads // to shows that version in the months config.roomSwaps gives it. it stays // the same room to everyone (same name, same doors in); only the file the // clients draw is the other one. const swappedRoom = (base, month = new Date().getUTCMonth() + 1) => { const swap = config.roomSwaps.find(candidate => candidate.room === base && candidate.months.includes(month)); return swap && defpacks.roomDef(swap.shown) ? swap.shown : base; }; // the room as this player should see it: the same room, loaded from the // build that has the look they picked, and as another room file of that // build where the theme names one. the client turns the path // into a file request, which lib/http.js answers from that build. dens keep // their one look. const roomAsSeenBy = (session, room) => { if (room.denOwner) { return room; } // A room may have been given a look of its own ("!theme here"). const chosen = Object.hasOwn(session.account.roomThemes, room.base) ? session.account.roomThemes[room.base] : session.account.theme; const theme = Object.hasOwn(config.themes, chosen) ? config.themes[chosen] : null; const themed = theme && theme.rooms && theme.rooms[room.base]; const base = themed && defpacks.roomDef(themed) ? themed : swappedRoom(room.base); return theme ? {...room, base: `${THEME_PATH_PREFIX}${theme.build}.${base}`} : {...room, base}; }; // has the player's client load the room they stand in again, in whatever // look it should have for them now. const reloadRoom = session => { if (session.room && !session.room.denOwner) { dens.sendRoomProperties(session, roomAsSeenBy(session, session.room)); for (const other of others(session)) { if (other.pos && sees(session, other)) { sendAvatarCreate(session, other); } } } }; // changes a player's seasonal theme ("" for none) and, if they are standing // in a room, has their client load it again. false for an unknown theme. const setTheme = (account, theme) => { if (theme !== "" && !Object.hasOwn(config.themes, theme)) { return false; } account.theme = theme; accounts.save(); const session = findOnline(account.username); if (session) { reloadRoom(session); } return true; }; // RoomXtCommManager.roomJoinResponse failure branch const joinFailed = (session, reason) => { console.log(`[world] ${session.name} could not join: ${reason}`); session.sendXt("rj", -1, 0, reason); }; // moves the session into the room called `name`, creating it from `base` // (a "path.name" from the room defPack) when nobody is in it yet. `props` // are what sets a den or a party room apart from a land: roomType, // secondaryDefId, denOwner, partyHost, customMusicDef. the client is told to // change rooms whether or not it asked to, which is also how a player is // sent somewhere (out of a den they were blocked from, say). // who came into whose den, for the owner's account page: the latest // visits, one line per visitor. const DEN_VISITS_KEPT = 50; const noteDenVisit = (owner, visitor) => { owner.denVisits = [{at: Math.floor(Date.now() / 1000), name: visitor.username}, ...owner.denVisits.filter(visit => visit.name !== visitor.username)].slice(0, DEN_VISITS_KEPT); }; const enterRoom = (session, name, base, displayName, shardId, props = {}) => { const def = defpacks.roomDef(base); let room = rooms.get(name); if (room && room === session.room) { return; } if (room && room.sessions.size >= config.maxUsersPerRoom) { joinFailed(session, "This room is currently full"); return; } minigames.leave(session); // walking into a room is how a full-screen game is left leaveRoom(session); if (!room) { room = {id: nextRoomId++, name, base, defId: Number(def.id), enviroType: Number(def.type), roomType: 0, secondaryDefId: 0, customMusicDef: 0, displayName, sessions: new Set(), ...props}; rooms.set(name, room); } room.sessions.add(session); session.room = room; if (props.denOwner && props.denOwner !== session.account) { noteDenVisit(props.denOwner, session.account); } roomInfo.ensure(base); const avatar = activeAvatar(session.account); pets.walked(session.account); // RoomXtCommManager.roomJoinResponse session.sendXt("rj", -1, 1, room.name, room.id, room.sessions.size, config.maxUsersPerRoom, 0, 0, // spectators, maxSpectators ...(room.joinFlags || [0, 0, 0, 0, 0]), // isPrivate, isGame, isLimbo, isTemp, isSubRoom (an adventure's room sets them) // the name shown in the corner of the screen, then the id of a // localization string to show in its place (GuiManager.setRoomNameDisplay); // 0 for "use the name". room.displayName, room.nameStringId || 0, avatar.perUserAvId, avatar.petInvId, LANG_ENG, room.customMusicDef, shardId); dens.sendRoomProperties(session, roomAsSeenBy(session, room)); for (const other of others(session)) { if (other.pos && sees(session, other)) { sendAvatarCreate(session, other); } } return room; }; const sendHome = session => { const shard = config.shards[0]; enterRoom(session, `${config.startupRoom}#${shard.id}`, config.startupRoom, roomInfo.name(config.startupRoom), shard.id); }; const emptyRoom = name => { const room = rooms.get(name); for (const session of room ? [...room.sessions] : []) { sendHome(session); } }; // the player's "hide blocked players" setting: with it on, animals of // players they blocked are not drawn for them. those in the room now come // or go at once. const setHideBlocked = (session, hide) => { const {account} = session; if (account.hideBlocked === hide) { return; } const blocked = others(session).filter(other => other.pos && blocks.has(account, other.account)); if (hide) { for (const other of blocked) { session.sendXt("ar", session.room.id, other.id); } } account.hideBlocked = hide; account.userVars[USER_VAR_HIDE_BLOCKED] = hide ? 1 : 0; accounts.save(); if (!hide) { for (const other of blocked) { sendAvatarCreate(session, other); } } }; // `session`'s player has just blocked `target`: out of their den or party // goes the blocked player, and out of sight if that is how they have it set. const onBlocked = (session, target) => { const targetSession = findOnline(target.username); if (!targetSession || !targetSession.room) { return; } const {room} = targetSession; if (room.denOwner === session.account || room.partyHost === session.account) { if (room.denOwner) { // DenXtCommManager.denPrivacyKickResponse: the client then explains // why it finds itself somewhere else. targetSession.sendXt("dpk", -1); } sendHome(targetSession); } else if (room === session.room && targetSession.pos && session.account.hideBlocked) { session.sendXt("ar", room.id, targetSession.id); } }; const onUnblocked = (session, target) => { const targetSession = findOnline(target.username); if (targetSession && targetSession.pos && targetSession.room === session.room && session.account.hideBlocked) { sendAvatarCreate(session, targetSession); } }; const joinRoom = (session, requested) => { // "jamaa_township.room_main#-1": path, then shard (-1 = pick one for me). let [base, shardText] = requested.split("@")[0].split("#"); // A party's room, which is where a buddy's "go to" can lead. if (parties.joinByRoomName(session, base)) { return; } // coming back from a full-screen game the client asks for the room it // was in by name, a den included (RoomManagerWorld.minigameJoinRoom). if (/^den/i.test(base) && accounts.byName(base.slice(3))) { joinDen(session, base); return; } base = base.toLowerCase(); // the game always asks for the same room first. A player who chose to // start in their den is put there instead (the game goes wherever the // reply says; a starting room in the flashvars it does not honour). if (!session.arrived) { session.arrived = true; const {startInDen, startRoom, username} = session.account; const den = startInDen ? username : /^den/i.test(startRoom || "") ? startRoom.slice(3) : null; if (den !== null && accounts.byName(den)) { joinDen(session, `den${den}`); return; } // any other name asked for that is a room here; else the usual one. const asked = (startRoom || "").split("#")[0].toLowerCase(); if (!startInDen && defpacks.roomDef(asked) && !asked.startsWith("den")) { base = asked; } } if (!defpacks.roomDef(base) || base.startsWith("den")) { joinFailed(session, `Room "${requested}" is not supported by this server`); return; } const shard = config.shards.find(s => s.id === Number(shardText)) || config.shards[0]; enterRoom(session, `${base}#${shard.id}`, base, roomInfo.name(base), shard.id); }; // dens are rooms named "den"; the client takes the owner from the name // and compares it to its own username, so the stored casing is used. const joinDen = (session, requested) => { const owner = accounts.byName(requested.slice(3)); // A row of the world map's Epic Dens list: a showcase den, which is a // room like any other (lib/epicdens.js). A player of that name comes first. const showcase = owner ? null : epicDens.byName(requested.slice(3)); if (showcase) { const shard = config.shards[0].id; enterRoom(session, `${showcase.base}#${shard}`, showcase.base, showcase.name, shard); return; } if (!requested.toLowerCase().startsWith("den") || !owner) { joinFailed(session, `Den "${requested}" does not exist`); return; } if (!dens.canEnter(owner, session.account) || blocks.has(owner, session.account)) { joinFailed(session, "This den is locked"); return; } // "'s Den" is what the client looks for to put a den's name in its // own words (GuiManager.setRoomNameDisplay). // ... unless the owner named the den themselves ("!den name"). const denName = owner.denNames[owner.activeDen]; const room = enterRoom(session, `den${owner.username}`, dens.denRoom(owner).base, denName ? `${owner.username}'s ${denName}` : `${owner.username}'s Den`, config.shards[0].id, {...dens.denRoom(owner), denOwner: owner}); if (room) { dens.sendDenState(session, room); } }; const seenUnhandled = new Set(); const unhandled = (cmd, params) => { const key = cmd === "gl" ? `gl ${params[0]}` : cmd; if (!seenUnhandled.has(key) && seenUnhandled.size < 500) { seenUnhandled.add(key); console.log(`[world] no handler for xt "${key}" (params: ${JSON.stringify(params).slice(0, 200)}) - the client gets no reply`); } }; // hosted parties end on the clock, not on anyone's request. setInterval(() => { try { parties.expire(emptyRoom); } catch (err) { console.error(`[world] ending parties failed: ${err.stack}`); } }, 60000).unref(); module.exports = { sys(session, msg) { if (msg.action === "login") { login(session, msg); return; } if (!session.account) { return; } switch (msg.action) { case "pubMsg": { // UserCommXtCommManager sends "%[%]" and reads it // back in userCommChatResponse as [sfsUserId, text, type, extra]. if (session.room && session.room.id === msg.roomId) { // at most text, type and one extra field, and no essays. const fields = decodeEntities(msg.cdata("txt") || "").split("%").slice(0, 3); if (fields[0].length > config.maxChatLength || (fields[2] || "").length > MAX_CHAT_EXTRA) { return; } // the type as the client will read it (int(), which makes 0 of // "00", of "abc" and of nothing at all): a whole number, written // one way, or the line is dropped. otherwise typed chat could be // sent as "00" and pass for something else here. if (!/^\d{1,2}$/.test(fields[1] || "")) { return; } fields[1] = String(Number(fields[1])); // typed chat shows as "..." over the sender until the server sends // it back (UserCommXtCommManager.sendChatMessage); everything else // the sender has already shown themselves. const echo = TYPED_CHAT_TYPES.includes(fields[1]); // silenced, or chat switched off on the account page: the line // goes nowhere. if (echo && (moderation.isSilenced(session.account) || !accounts.featureOn(session.account, "chat"))) { session.sendXt("uc", session.room.id, session.id, -1, 5); return; } // A few lines in a few seconds, and no more: the bubble waiting // for this one is cleared, as for a silenced player. if (echo && !limits.isTrustedLocal(session.address) && !chatLines.allow(session.account.id)) { session.sendXt("uc", session.room.id, session.id, -1, 5); return; } if (echo) { // "!help" and the like (lib/commands.js). A command's line is // still echoed to its sender, whose chat bubble waits for it. const said = commands.run(session, fields[0]); if (said === null) { session.sendXt("uc", session.room.id, session.id, ...fields); return; } fields[0] = said; session.recentChat.push(`${new Date().toISOString().slice(11, 19)} ${said}`); session.recentChat = session.recentChat.slice(-RECENT_CHAT_LINES); chatlog.record(session.account, session.room.name, said); } // nobody hears a player they have blocked, and with chat switched // off nobody's typed lines arrive at all. for (const recipient of echo ? session.room.sessions : others(session)) { if (recipient === session || (!blocks.has(recipient.account, session.account) && (!echo || accounts.featureOn(recipient.account, "chat")))) { recipient.sendXt("uc", session.room.id, session.id, ...fields); } } } return; } case "logout": session.close(); return; default: console.log(`[world] unhandled sys "${msg.action}" from ${session.name}`); } }, xt(session, cmd, roomId, params) { if (!session.account) { if (session.signingUp && Object.hasOwn(signup.handlers, cmd)) { signup.handlers[cmd](session, roomId, params); } return; } if (Object.hasOwn(handlers, cmd)) { // clothing and den item purchases, for "!again". if (cmd === "ib" || cmd === "db") { session.lastPurchase = {cmd, roomId, params}; } handlers[cmd](session, roomId, params); } else { unhandled(cmd, params); } }, close: leaveWorld, findOnline, sendItemList, setTheme, // offers left on the account page (lib/trades.js); `refresh` shows a // playing account its inventories as they are now. tradeOffers: trades.offers, refreshInventories(account) { const session = findOnline(account.username); if (session) { sendItemList(session, session, true); dens.sendDenItems(session); } }, // runs a chat command for an account that is playing, as if typed. false // when it is not in the game. runCommand(account, text) { const session = findOnline(account.username); if (!session || !session.room) { return false; } commands.run(session, text); return true; }, // blocks or unblocks `target` for `account` from outside the game (the // account page). false when there was nothing to change. setBlocked(account, target, block) { const key = target.username.toLowerCase(); if (account.blocked.includes(key) === block || (block && account.blocked.length >= MAX_BLOCKED)) { return false; } account.blocked = block ? [...account.blocked, key] : account.blocked.filter(name => name !== key); accounts.save(); const session = findOnline(account.username); if (session) { (block ? onBlocked : onUnblocked)(session, target); buddies.handlers.bl(session); // their game's own lists, brought up to date } return true; }, moderation, walls, ecards, // called when the admin changed an account's badges: a name tag showing // one it no longer holds goes back to the first badge, for everyone who // sees it. checkNameTag(account) { if (badges.mayWear(account, defpacks.badgeIds()[account.nameBarData >> 8 & 0xFF])) { return; } account.nameBarData &= ~0xFF00; accounts.save(); const session = findOnline(account.username); if (session && session.room) { // AvatarXtCommManager "an": [sfsUserId, nameBarData] for (const viewer of session.room.sessions) { viewer.sendXt("an", session.room.id, session.id, account.nameBarData); } } }, // the adventure level of the animal an account is using, set from the // admin panel. clients in the room hear of it through an `ad` they did // not ask for; a name tag draws the new level when it is next made. setQuestLevel(account, level) { const avatar = activeAvatar(account); avatar.questLevel = level; avatar.questXp = adventureModule.levelXp(level); accounts.save(); const session = findOnline(account.username); if (session && session.room) { for (const viewer of session.room.sessions) { sendAvatarData(viewer, session, avatar.perUserAvId); } } }, motd: () => accounts.setting(MOTD_SETTING) || "", setMotd(text) { accounts.setSetting(MOTD_SETTING, String(text).trim().slice(0, MAX_ANNOUNCEMENT)); }, // shows a message to everyone playing, or to everyone in one room. returns // how many players got it. announce(text, roomName = null) { const audience = [...online.values()].filter(session => session.pos && (!roomName || (session.room && session.room.name === roomName))); for (const session of audience) { tell(session, text); } return audience.length; }, // an "Animal Jam HQ" popup for one player; false when they are not playing. tellAccount(account, text) { const session = findOnline(account.username); if (session && session.pos) { tell(session, text); } return Boolean(session && session.pos); }, rooms: () => [...rooms.values()].map(room => ({name: room.name, title: commands.roomTitle(room), players: room.sessions.size})), // the panel's Masterpieces page. A painting waiting for review is an // item its maker cannot use yet; approving it tells them so, by a // Jam-A-Gram from Animal Jam HQ and at once if they are playing. approveMasterpiece(id) { const maker = masterpieces.creatorOf(id); if (!masterpieces.approve(id)) { return false; } if (maker) { ecards.noteFromHq(maker, "Your Masterpiece has been approved! It is with your den items."); const session = findOnline(maker.username); if (session) { dens.sendDenItems(session); } } return true; }, // takes a painting away for good, from whoever has it by now: one that // was not approved, or one that should not have been. its maker gets a // Masterpiece Token to frame another with, and word of it. removeMasterpiece(id) { const painting = masterpieces.get(id); const maker = masterpieces.creatorOf(id); if (!painting) { return false; } const changed = new Set(maker ? [maker] : []); const shownIn = []; for (const account of accounts.all()) { const held = account.denItems.filter(item => item.image === painting.id); if (held.length === 0) { continue; } changed.add(account); if (held.some(item => item.placed)) { shownIn.push(rooms.get(`den${account.username}`)); } account.denItems = account.denItems.filter(item => item.image !== painting.id); account.tradeList = account.tradeList.filter(listed => !(listed.type === 1 && held.some(item => item.inv === listed.inv))); } masterpieces.forget(painting.id); if (maker) { dens.giveDenItem(maker, masterpieces.TOKEN_DEN_ITEM); ecards.noteFromHq(maker, "Your Masterpiece was not approved. Here is a Masterpiece Token to frame another one with."); } for (const account of changed) { const session = findOnline(account.username); if (session) { dens.sendDenItems(session); } } for (const room of shownIn.filter(Boolean)) { for (const visitor of room.sessions) { dens.sendDenState(visitor, room, false); } } accounts.save(); return true; }, // the panel's Debug page: puts a playing account into any room of the room // list, as that room and nothing more (a den's file without its owner, a // party's without the party). returns what is wrong, or null. teleport(account, path) { const session = findOnline(account.username); const base = String(path).replace(/\//g, ".").toLowerCase(); if (!session || !session.room) { return "They are not in the game right now"; } if (!defpacks.roomDef(base)) { return "There is no such room"; } minigames.leave(session); const shard = config.shards[0].id; enterRoom(session, `${base}#${shard}`, base, roomInfo.name(base), shard); return null; }, // an address was just banned (lib/bans.js): whoever plays from it is told // as for a ban of their own, and put out. returns how many. disconnectAddress(address) { const there = [...online.values()].filter(session => limits.key(session.address) === limits.key(address)); for (const session of there) { session.sendXt("fd", -1, "fb", 1, moderation.PERMANENT); session.close(); } return there.length; }, // takes the account out of the world at once (not when its socket gets // round to closing), so the caller can go on to rename or delete it. disconnect(account) { parties.forget(account, emptyRoom); const session = findOnline(account.username); if (session) { leaveWorld(session); session.close(); } }, players: () => [...online.values()].map(session => ({ username: session.account.username, room: session.room ? session.room.name : null, address: session.address, })), };