350 lines
No EOL
12 KiB
TypeScript
350 lines
No EOL
12 KiB
TypeScript
import config from "../config.json";
|
|
import { ConsoleHelper } from "../ConsoleHelper";
|
|
import { Database } from "./objects/Database";
|
|
import { UserArray } from "./objects/UserArray";
|
|
import { LatLng } from "./objects/LatLng";
|
|
import { Packets } from "./enums/Packets";
|
|
import { RedisClientType, createClient } from "redis";
|
|
import { replaceAll } from "./Util";
|
|
import { Request, Response } from "express";
|
|
import { User } from "./objects/User";
|
|
import * as osu from "osu-packet";
|
|
|
|
/*const
|
|
loginHandler = require("./loginHandler.js"),
|
|
parseUserData = require("./util/parseUserData.js"),
|
|
getUserFromToken = require("./util/getUserByToken.js"),
|
|
getUserById = require("./util/getUserById.js"),
|
|
bakedResponses = require("./bakedResponses.js"),
|
|
Streams = require("./Streams.js");*/
|
|
|
|
const DB:Database = new Database(config.database.address, config.database.port, config.database.username, config.database.password, config.database.name, async () => {
|
|
// Close any unclosed db matches on startup
|
|
DB.query("UPDATE mp_matches SET close_time = UNIX_TIMESTAMP() WHERE close_time IS NULL");
|
|
DB.query("UPDATE osu_info SET value = 0 WHERE name = 'online_now'");
|
|
});
|
|
|
|
// Users funkyArray for session storage
|
|
const users = new UserArray();
|
|
|
|
// Add the bot user
|
|
const botUser:User = users.add("bot", new User(3, "SillyBot", "bot", DB));
|
|
// Set the bot's position on the map
|
|
botUser.location = new LatLng(50, -32);
|
|
|
|
let redisClient:RedisClientType;
|
|
|
|
async function subscribeToChannel(channelName:string, callback:(message:string) => void) {
|
|
// Dup and connect new client for channel subscription (required)
|
|
const subscriptionClient:RedisClientType = redisClient.duplicate();
|
|
await subscriptionClient.connect();
|
|
// Subscribe to channel
|
|
await subscriptionClient.subscribe(channelName, callback);
|
|
ConsoleHelper.printRedis(`Subscribed to ${channelName} channel`);
|
|
}
|
|
|
|
if (config.redis.enabled) {
|
|
(async () => {
|
|
redisClient = createClient({
|
|
url: `redis://${replaceAll(config.redis.password, " ", "") == "" ? "" : `${config.redis.password}@`}${config.redis.address}:${config.redis.port}/${config.redis.database}`
|
|
});
|
|
|
|
redisClient.on('error', e => ConsoleHelper.printRedis(e));
|
|
|
|
const connectionStartTime = Date.now();
|
|
await redisClient.connect();
|
|
ConsoleHelper.printRedis(`Connected to redis server. Took ${Date.now() - connectionStartTime}ms`);
|
|
|
|
// Score submit update channel
|
|
subscribeToChannel("binato:update_user_stats", (message) => {
|
|
if (typeof(message) === "string") {
|
|
const user = users.getById(parseInt(message));
|
|
// Update user info
|
|
user.updateUserInfo(true);
|
|
|
|
ConsoleHelper.printRedis(`Score submission stats update request received for ${user.username}`);
|
|
}
|
|
});
|
|
})();
|
|
} else ConsoleHelper.printWarn("Redis is disabled!");
|
|
|
|
// User timeout interval
|
|
setInterval(() => {
|
|
for (let User of users.getIterableItems()) {
|
|
if (User.id == 3) continue; // Ignore the bot
|
|
// Bot: :(
|
|
|
|
// Logout this user, they're clearly gone.
|
|
if (Date.now() >= User.timeoutTime)
|
|
Logout(User);
|
|
}
|
|
}, 10000);
|
|
|
|
// Init stream class
|
|
//Streams.init();
|
|
|
|
// An array containing all chat channels
|
|
/*global.channels = [
|
|
{ channelName:"#osu", channelTopic:"The main channel", channelUserCount: 0, locked: false },
|
|
{ channelName:"#userlog", channelTopic:"Log about stuff doing go on yes very", channelUserCount: 0, locked: false },
|
|
{ channelName:"#lobby", channelTopic:"Talk about multiplayer stuff", channelUserCount: 0, locked: false },
|
|
{ channelName:"#english", channelTopic:"Talk in exclusively English", channelUserCount: 0, locked: false },
|
|
{ channelName:"#japanese", channelTopic:"Talk in exclusively Japanese", channelUserCount: 0, locked: false },
|
|
];*/
|
|
|
|
// Create a stream for each chat channel
|
|
/*for (let i = 0; i < global.channels.length; i++) {
|
|
Streams.addStream(global.channels[i].channelName, false);
|
|
}*/
|
|
|
|
// Add a stream for the multiplayer lobby
|
|
//Streams.addStream("multiplayer_lobby", false);
|
|
|
|
// Include packets
|
|
const ChangeAction = require("./Packets/ChangeAction.js"),
|
|
SendPublicMessage = require("./Packets/SendPublicMessage.js"),
|
|
Logout = require("./Packets/Logout.js"),
|
|
Spectator = require("./Spectator.js"),
|
|
SendPrivateMessage = require("./Packets/SendPrivateMessage.js"),
|
|
MultiplayerManager = require("./MultiplayerManager.js"),
|
|
SetAwayMessage = require("./Packets/SetAwayMessage.js"),
|
|
ChannelJoin = require("./Packets/ChannelJoin.js"),
|
|
ChannelPart = require("./Packets/ChannelPart.js"),
|
|
AddFriend = require("./Packets/AddFriend.js"),
|
|
RemoveFriend = require("./Packets/RemoveFriend.js"),
|
|
UserPresenceBundle = require("./Packets/UserPresenceBundle.js"),
|
|
UserPresence = require("./Packets/UserPresence.js"),
|
|
UserStatsRequest = require("./Packets/UserStatsRequest.js"),
|
|
MultiplayerInvite = require("./Packets/MultiplayerInvite.js"),
|
|
TourneyMatchSpecialInfo = require("./Packets/TourneyMatchSpecialInfo.js"),
|
|
TourneyMatchJoinChannel = require("./Packets/TourneyMatchSpecialInfo.js"),
|
|
TourneyMatchLeaveChannel = require("./Packets/TourneyLeaveMatchChannel.js");
|
|
|
|
// A class for managing everything multiplayer
|
|
const multiplayerManager:MultiplayerManager = new MultiplayerManager();
|
|
|
|
export async function HandleRequest(req:Request, res:Response, packet:Buffer) {
|
|
// Get the client's token string and request data
|
|
const requestTokenString:string | undefined = req.header("osu-token"),
|
|
requestData:Buffer = packet;
|
|
|
|
// Server's response
|
|
let responseData:Buffer;
|
|
|
|
// Check if the user is logged in
|
|
if (requestTokenString == null) {
|
|
// Client doesn't have a token yet, let's auth them!
|
|
const userData = parseUserData(requestData);
|
|
ConsoleHelper.printBancho(`New client connection. [User: ${userData.username}]`);
|
|
await loginHandler(req, res, userData);
|
|
} else {
|
|
// Client has a token, let's see what they want.
|
|
try {
|
|
// Get the current user
|
|
const PacketUser:User = users.getByToken(requestTokenString);
|
|
|
|
// Make sure the client's token isn't invalid
|
|
if (PacketUser != null) {
|
|
// Update the session timeout time
|
|
PacketUser.timeoutTime = Date.now() + 60000;
|
|
|
|
// Create a new osu! packet reader
|
|
const osuPacketReader = new osu.Client.Reader(requestData);
|
|
// Parse current bancho packet
|
|
const PacketData = osuPacketReader.Parse();
|
|
|
|
// Go through each packet sent by the client
|
|
for (let CurrentPacket of PacketData) {
|
|
switch (CurrentPacket.id) {
|
|
case Packets.Client_ChangeAction:
|
|
ChangeAction(PacketUser, CurrentPacket.data);
|
|
break;
|
|
|
|
case Packets.Client_SendPublicMessage:
|
|
SendPublicMessage(PacketUser, CurrentPacket.data);
|
|
break;
|
|
|
|
case Packets.Client_Logout:
|
|
await Logout(PacketUser);
|
|
break;
|
|
|
|
case Packets.Client_RequestStatusUpdate:
|
|
UserPresenceBundle(PacketUser);
|
|
break;
|
|
|
|
case Packets.Client_StartSpectating:
|
|
Spectator.startSpectatingUser(PacketUser, CurrentPacket.data);
|
|
break;
|
|
|
|
case Packets.Client_SpectateFrames:
|
|
Spectator.sendSpectatorFrames(PacketUser, CurrentPacket.data);
|
|
break;
|
|
|
|
case Packets.Client_StopSpectating:
|
|
Spectator.stopSpectatingUser(PacketUser);
|
|
break;
|
|
|
|
case Packets.Client_sendPrivateMessage:
|
|
SendPrivateMessage(PacketUser, CurrentPacket.data);
|
|
break;
|
|
|
|
case Packets.Client_joinLobby:
|
|
global.MultiplayerManager.userEnterLobby(PacketUser);
|
|
break;
|
|
|
|
case Packets.Client_partLobby:
|
|
global.MultiplayerManager.userLeaveLobby(PacketUser);
|
|
break;
|
|
|
|
case Packets.Client_createMatch:
|
|
await global.MultiplayerManager.createMultiplayerMatch(PacketUser, CurrentPacket.data);
|
|
break;
|
|
|
|
case Packets.Client_joinMatch:
|
|
global.MultiplayerManager.joinMultiplayerMatch(PacketUser, CurrentPacket.data);
|
|
break;
|
|
|
|
case Packets.Client_matchChangeSlot:
|
|
PacketUser.currentMatch.moveToSlot(PacketUser, CurrentPacket.data);
|
|
break;
|
|
|
|
case Packets.Client_matchReady:
|
|
PacketUser.currentMatch.setStateReady(PacketUser);
|
|
break;
|
|
|
|
case Packets.Client_matchChangeSettings:
|
|
await PacketUser.currentMatch.updateMatch(PacketUser, CurrentPacket.data);
|
|
break;
|
|
|
|
case Packets.Client_matchNotReady:
|
|
PacketUser.currentMatch.setStateNotReady(PacketUser);
|
|
break;
|
|
|
|
case Packets.Client_partMatch:
|
|
await global.MultiplayerManager.leaveMultiplayerMatch(PacketUser);
|
|
break;
|
|
|
|
// Also handles user kick if the slot has a user
|
|
case Packets.Client_matchLock:
|
|
PacketUser.currentMatch.lockMatchSlot(PacketUser, CurrentPacket.data);
|
|
break;
|
|
|
|
case Packets.Client_matchNoBeatmap:
|
|
PacketUser.currentMatch.missingBeatmap(PacketUser);
|
|
break;
|
|
|
|
case Packets.Client_matchSkipRequest:
|
|
PacketUser.currentMatch.matchSkip(PacketUser);
|
|
break;
|
|
|
|
case Packets.Client_matchHasBeatmap:
|
|
PacketUser.currentMatch.notMissingBeatmap(PacketUser);
|
|
break;
|
|
|
|
case Packets.Client_matchTransferHost:
|
|
PacketUser.currentMatch.transferHost(PacketUser, CurrentPacket.data);
|
|
break;
|
|
|
|
case Packets.Client_matchChangeMods:
|
|
PacketUser.currentMatch.updateMods(PacketUser, CurrentPacket.data);
|
|
break;
|
|
|
|
case Packets.Client_matchStart:
|
|
PacketUser.currentMatch.startMatch();
|
|
break;
|
|
|
|
case Packets.Client_matchLoadComplete:
|
|
PacketUser.currentMatch.matchPlayerLoaded(PacketUser);
|
|
break;
|
|
|
|
case Packets.Client_matchComplete:
|
|
await PacketUser.currentMatch.onPlayerFinishMatch(PacketUser);
|
|
break;
|
|
|
|
case Packets.Client_matchScoreUpdate:
|
|
PacketUser.currentMatch.updatePlayerScore(PacketUser, CurrentPacket.data);
|
|
break;
|
|
|
|
case Packets.Client_matchFailed:
|
|
PacketUser.currentMatch.matchFailed(PacketUser);
|
|
break;
|
|
|
|
case Packets.Client_matchChangeTeam:
|
|
PacketUser.currentMatch.changeTeam(PacketUser);
|
|
break;
|
|
|
|
case Packets.Client_channelJoin:
|
|
ChannelJoin(PacketUser, CurrentPacket.data);
|
|
break;
|
|
|
|
case Packets.Client_channelPart:
|
|
ChannelPart(PacketUser, CurrentPacket.data);
|
|
break;
|
|
|
|
case Packets.Client_setAwayMessage:
|
|
SetAwayMessage(PacketUser, CurrentPacket.data);
|
|
break;
|
|
|
|
case Packets.Client_friendAdd:
|
|
AddFriend(PacketUser, CurrentPacket.data);
|
|
break;
|
|
|
|
case Packets.Client_friendRemove:
|
|
RemoveFriend(PacketUser, CurrentPacket.data);
|
|
break;
|
|
|
|
case Packets.Client_userStatsRequest:
|
|
UserStatsRequest(PacketUser, CurrentPacket.data);
|
|
break;
|
|
|
|
case Packets.Client_specialMatchInfoRequest:
|
|
TourneyMatchSpecialInfo(PacketUser, CurrentPacket.data);
|
|
break;
|
|
|
|
case Packets.Client_specialJoinMatchChannel:
|
|
TourneyMatchJoinChannel(PacketUser, CurrentPacket.data);
|
|
break;
|
|
|
|
case Packets.Client_specialLeaveMatchChannel:
|
|
TourneyMatchLeaveChannel(PacketUser, CurrentPacket.data);
|
|
break;
|
|
|
|
case Packets.Client_invite:
|
|
MultiplayerInvite(PacketUser, CurrentPacket.data);
|
|
break;
|
|
|
|
case Packets.Client_userPresenceRequest:
|
|
UserPresence(PacketUser, PacketUser.id); // Can't really think of a way to generalize this?
|
|
break;
|
|
|
|
default:
|
|
// Ignore client_beatmapInfoRequest and client_receiveUpdates
|
|
if (CurrentPacket.id == 68 || CurrentPacket.id == 79 || CurrentPacket.id == 4) break;
|
|
// Print out unimplemented packet
|
|
console.dir(CurrentPacket);
|
|
break;
|
|
}
|
|
}
|
|
|
|
responseData = PacketUser.queue;
|
|
PacketUser.clearQueue();
|
|
} else {
|
|
// User's token is invlid, force a reconnect
|
|
consoleHelper.printBancho(`Forced client re-login (Token is invalid)`);
|
|
responseData = bakedResponses("reconnect");
|
|
}
|
|
} catch (e) {
|
|
console.error(e);
|
|
} finally {
|
|
// Only send the headers that we absolutely have to
|
|
res.removeHeader('X-Powered-By');
|
|
res.removeHeader('Date');
|
|
res.writeHead(200, {
|
|
"Connection": "keep-alive",
|
|
"Keep-Alive": "timeout=5, max=100",
|
|
});
|
|
// Send the prepared packet(s) to the client
|
|
res.end(responseData);
|
|
}
|
|
}
|
|
}; |