313 lines
No EOL
13 KiB
JavaScript
313 lines
No EOL
13 KiB
JavaScript
const osu = require("osu-packet"),
|
|
fs = require("fs"),
|
|
packetIDs = require("./packetIDs.json"),
|
|
loginHandler = require("./loginHandler.js"),
|
|
parseUserData = require("./util/parseUserData.js"),
|
|
User = require("./User.js"),
|
|
getUserFromToken = require("./util/getUserByToken.js"),
|
|
bakedResponses = require("./bakedResponses.js"),
|
|
Streams = require("./Streams.js"),
|
|
DatabaseHelperClass = require("./DatabaseHelper.js"),
|
|
config = require("../config.json");
|
|
|
|
global.users = [
|
|
new User(3, "SillyBot", "SillyBot", new Date().getTime())
|
|
];
|
|
|
|
// Set the bot's position on the map
|
|
// First user will always be the bot
|
|
global.users[0].location[0] = 50;
|
|
global.users[0].location[1] = -32;
|
|
|
|
global.DatabaseHelper = new DatabaseHelperClass(config.databaseAddress, config.databasePort, config.databaseKey);
|
|
|
|
|
|
// Start a loop that gets new data for users from the database for use on the user panel
|
|
// TODO: Some way of informing bancho that a user has set a score so details can be pulled down quickly
|
|
// Possible solution, TCP socket between the score submit server and bancho? redis? (score submit is on a different server, redis probably wouldn't work)
|
|
setInterval(() => {
|
|
for (let i = 0; i < global.users.length; i++) {
|
|
const User = global.users[i];
|
|
if (User.id == 3) continue; // Ignore the bot
|
|
// Bot: :(
|
|
|
|
User.getNewUserInformationFromDatabase();
|
|
}
|
|
}, 10000);
|
|
|
|
// An array containing all currently active multiplayer matches
|
|
global.matches = [];
|
|
// An array containing the last 15 messages in chat
|
|
// TODO: Bother making this
|
|
global.chatHistory = [];
|
|
global.StreamsHandler = new Streams();
|
|
|
|
// An array containing all chat channels
|
|
// TODO: Send user chat channels and not have osu! crash
|
|
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++) {
|
|
global.StreamsHandler.addStream(global.channels[i].channelName, false);
|
|
}
|
|
|
|
// Add a stream for the multiplayer lobby
|
|
global.StreamsHandler.addStream("multiplayer_lobby", false);
|
|
|
|
// Start stream checking interval
|
|
global.StreamsHandler.streamChecker(5000);
|
|
|
|
// Server stats
|
|
global.usersOnline = 0;
|
|
global.multiplayerMatches = [0, 0]
|
|
global.httpRequestsPerLogInterval = 0;
|
|
|
|
const logInterval = 10; // Secs
|
|
|
|
setInterval(() => {
|
|
global.usersOnline = (global.users.length - 1);
|
|
global.multiplayerMatches = [global.matches.length, 0]; // TODO: Respect private matches
|
|
|
|
fs.appendFile(
|
|
"server-stats.log",
|
|
`${global.usersOnline}|${global.multiplayerMatches[0]},${global.multiplayerMatches[1]}|${global.httpRequestsPerLogInterval}|${new Date().getTime()}@`,
|
|
() => { }
|
|
);
|
|
|
|
global.usersOnline = 0;
|
|
global.multiplayerMatches = [0, 0];
|
|
global.httpRequestsPerLogInterval = 0;
|
|
}, logInterval * 1000);
|
|
|
|
// 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"),
|
|
Multiplayer = require("./Multiplayer.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");
|
|
|
|
module.exports = function(req, res) {
|
|
// Add to requests for logging
|
|
global.httpRequestsPerLogInterval++;
|
|
|
|
// Get the client's token string and request data
|
|
const requestTokenString = req.header("osu-token"),
|
|
requestData = req.packet;
|
|
|
|
// Server's response & new client token
|
|
let responseTokenString = "",
|
|
responseData = new Buffer.alloc(0);
|
|
|
|
// 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);
|
|
global.consoleHelper.printBancho(`New client connection. [User: ${userData.username}]`);
|
|
loginHandler(req, res, userData);
|
|
} else {
|
|
// Client has a token, let's see what they want.
|
|
try {
|
|
// Get the current user
|
|
const userClass = getUserFromToken(requestTokenString);
|
|
|
|
// Make sure the client's token isn't invalid
|
|
if (userClass != null) {
|
|
// Create a new osu! packet reader
|
|
const osuPacketReader = new osu.Client.Reader(requestData);
|
|
// Parse current bancho packet
|
|
const PacketData = osuPacketReader.Parse();
|
|
// Loop through parsed packet data
|
|
for (let i = 0; i < PacketData.length; i++) {
|
|
// Get current packet
|
|
let CurrentPacket = PacketData[i];
|
|
|
|
switch (CurrentPacket.id) {
|
|
case packetIDs.client_changeAction:
|
|
ChangeAction(userClass, CurrentPacket.data);
|
|
break;
|
|
|
|
case packetIDs.client_sendPublicMessage:
|
|
SendPublicMessage(CurrentPacket, userClass);
|
|
break;
|
|
|
|
case packetIDs.client_logout:
|
|
Logout(userClass);
|
|
break;
|
|
|
|
case packetIDs.client_requestStatusUpdate:
|
|
UserPresenceBundle(userClass);
|
|
break;
|
|
|
|
case packetIDs.client_pong: // Pretty sure this is just a client ping
|
|
// so we probably don't do anything here
|
|
break;
|
|
|
|
case packetIDs.client_startSpectating:
|
|
Spectator.startSpectatingUser(CurrentPacket.data, userClass);
|
|
break;
|
|
|
|
case packetIDs.client_spectateFrames:
|
|
Spectator.sendSpectatorFrames(userClass, CurrentPacket.data);
|
|
break;
|
|
|
|
case packetIDs.client_stopSpectating:
|
|
Spectator.stopSpectatingUser(userClass);
|
|
break;
|
|
|
|
case packetIDs.client_sendPrivateMessage:
|
|
SendPrivateMessage(CurrentPacket, userClass);
|
|
break;
|
|
|
|
case packetIDs.client_joinLobby:
|
|
Multiplayer.userEnterLobby(userClass);
|
|
break;
|
|
|
|
case packetIDs.client_partLobby:
|
|
Multiplayer.userLeaveLobby(userClass);
|
|
break;
|
|
|
|
case packetIDs.client_createMatch:
|
|
Multiplayer.createMultiplayerMatch(userClass, CurrentPacket.data);
|
|
break;
|
|
|
|
case packetIDs.client_joinMatch:
|
|
Multiplayer.joinMultiplayerMatch(userClass, CurrentPacket.data);
|
|
break;
|
|
|
|
case packetIDs.client_matchChangeSlot:
|
|
Multiplayer.moveToSlot(userClass, CurrentPacket.data);
|
|
break;
|
|
|
|
case packetIDs.client_matchReady:
|
|
Multiplayer.setReadyState(userClass, true);
|
|
break;
|
|
|
|
case packetIDs.client_matchChangeSettings:
|
|
Multiplayer.updateMatch(userClass, CurrentPacket.data);
|
|
break;
|
|
|
|
case packetIDs.client_matchNotReady:
|
|
Multiplayer.setReadyState(userClass, false);
|
|
break;
|
|
|
|
case packetIDs.client_partMatch:
|
|
Multiplayer.leaveMatch(userClass);
|
|
break;
|
|
|
|
case packetIDs.client_matchLock: // Also handles user kick
|
|
Multiplayer.kickPlayer(userClass, CurrentPacket.data);
|
|
break;
|
|
|
|
case packetIDs.client_matchNoBeatmap:
|
|
Multiplayer.missingBeatmap(userClass, true);
|
|
break;
|
|
|
|
case packetIDs.client_matchSkipRequest:
|
|
Multiplayer.matchSkip(userClass);
|
|
break;
|
|
|
|
case packetIDs.client_matchHasBeatmap:
|
|
Multiplayer.missingBeatmap(userClass, false);
|
|
break;
|
|
|
|
case packetIDs.client_matchTransferHost:
|
|
Multiplayer.transferHost(userClass, CurrentPacket.data);
|
|
break;
|
|
|
|
case packetIDs.client_matchChangeMods:
|
|
Multiplayer.updateMods(userClass, CurrentPacket.data);
|
|
break;
|
|
|
|
case packetIDs.client_matchStart:
|
|
Multiplayer.startMatch(userClass);
|
|
break;
|
|
|
|
case packetIDs.client_matchLoadComplete:
|
|
Multiplayer.setPlayerLoaded(userClass);
|
|
break;
|
|
|
|
case packetIDs.client_matchComplete:
|
|
Multiplayer.onPlayerFinishMatch(userClass);
|
|
break;
|
|
|
|
case packetIDs.client_matchScoreUpdate:
|
|
Multiplayer.updatePlayerScore(userClass, CurrentPacket.data);
|
|
break;
|
|
|
|
case packetIDs.client_matchFailed:
|
|
break;
|
|
|
|
case packetIDs.client_channelJoin:
|
|
// TODO: Implement user channel joining
|
|
// Auto channel joining is already complete
|
|
break;
|
|
|
|
case packetIDs.client_channelPart:
|
|
ChannelPart(userClass, CurrentPacket.data);
|
|
break;
|
|
|
|
case packetIDs.client_friendAdd:
|
|
AddFriend(userClass, CurrentPacket.data);
|
|
break;
|
|
|
|
case packetIDs.client_friendRemove:
|
|
RemoveFriend(userClass, CurrentPacket.data);
|
|
break;
|
|
|
|
case packetIDs.client_userStatsRequest:
|
|
UserStatsRequest(userClass, CurrentPacket.data);
|
|
break;
|
|
|
|
case packetIDs.client_invite:
|
|
MultiplayerInvite(userClass, CurrentPacket.data);
|
|
break;
|
|
|
|
case packetIDs.client_userPresenceRequest:
|
|
UserPresence(userClass, userClass.id);
|
|
break;
|
|
|
|
default:
|
|
// Ignore client_beatmapInfoRequest and client_receiveUpdates
|
|
if (CurrentPacket.id == 68 || CurrentPacket.id == 79) break;
|
|
// Print out unimplemented packet
|
|
console.dir(CurrentPacket);
|
|
break;
|
|
}
|
|
|
|
// Put current user queue into response data
|
|
responseData = Buffer.concat([responseData, userClass.queue], responseData.length + userClass.queue.length);
|
|
userClass.clearQueue();
|
|
}
|
|
} else {
|
|
// User's token is invlid, force a reconnect
|
|
global.consoleHelper.printBancho(`Forced client re-login (Token is invalid)`);
|
|
responseData = bakedResponses("reconnect");
|
|
}
|
|
} catch (e) {
|
|
console.error(e);
|
|
} finally {
|
|
// Send the prepared packet to the client
|
|
res.writeHead(200, {
|
|
"cho-protocol": 19,
|
|
"Connection": "keep-alive",
|
|
"Keep-Alive": "timeout=5, max=100",
|
|
"Content-Type": "text/html; charset=UTF-8"
|
|
});
|
|
res.end(responseData);
|
|
}
|
|
}
|
|
}; |