Binato/server/serverHandler.js

const osu = require("osu-packet"),
      fs = require("fs"),
      packetIDs = require("./packetIDs.js"),
      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 = {};
global.userKeys = Object.keys(global.users);

global.addUser = function(uuid, userToAdd) {
    global.users[uuid] = userToAdd;
    global.refreshUserKeys();
}

global.removeUser = function(userToRemove) {
    delete userToRemove;
    global.refreshUserKeys();
}

global.refreshUserKeys = function() {
    global.userKeys = Object.keys(global.users);
}

// Add the bot user
global.addUser("bot", new User(3, "SillyBot", "bot", new Date().getTime()));
// Set the bot's position on the map
global.users["bot"].location[0] = 50;
global.users["bot"].location[1] = -32;

global.DatabaseHelper = new DatabaseHelperClass(config.databaseAddress, config.databasePort, config.databaseUsername, config.databasePassword, config.databaseName);


// 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.userKeys.length; i++) {
        const User = global.users[global.userKeys[i]];
        if (User.id == 3) continue; // Ignore the bot
                                    // Bot: :(

        User.getNewUserInformationFromDatabase();
    }
}, 10000);

// An array containing the last 15 messages in chat
// TODO: Bother making this
global.chatHistory = [];
global.addChatMessage = function(msg) {
    if (global.chatHistory.length == 15) {
        global.chatHistory.splice(0, 1);
        global.chatHistory.push(msg);
    } else {
        global.chatHistory.push(msg);
    }
}

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.userKeys.length - 1);
    global.multiplayerMatches = [global.MultiplayerManager.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.httpRequestsPerLogInterval = 0;
}, logInterval * 1000);

if (!fs.existsSync("tHMM.ds")) fs.writeFileSync("tHMM.ds", "0");
global.totalHistoricalMultiplayerMatches = parseInt(fs.readFileSync("tHMM.ds").toString());
global.getAndAddToHistoricalMultiplayerMatches = function() {
    global.totalHistoricalMultiplayerMatches++;
    fs.writeFile("tHMM.ds", `${global.totalHistoricalMultiplayerMatches}`, () => {});
    return global.totalHistoricalMultiplayerMatches;
}

// 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"),
      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
global.MultiplayerManager = new MultiplayerManager();

module.exports = async 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 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}]`);
        await loginHandler(req, res, userData);
    } else {
        // Client has a token, let's see what they want.
        try {
            // Get the current user
            const PacketUser = getUserFromToken(requestTokenString);

            // Make sure the client's token isn't invalid
            if (PacketUser != 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];
                    
                    // This is getting a little big, swap this out for mapped functions?
                    // Would require some standardisation
                    switch (CurrentPacket.id) {
                        case packetIDs.client_changeAction:
                            ChangeAction(PacketUser, CurrentPacket.data);
                        break;

                        case packetIDs.client_sendPublicMessage:
                            SendPublicMessage(PacketUser, CurrentPacket);
                        break;

                        case packetIDs.client_logout:
                            Logout(PacketUser);
                        break;

                        case packetIDs.client_requestStatusUpdate:
                            UserPresenceBundle(PacketUser);
                        break;

                        case packetIDs.client_pong: // Pretty sure this is just a client ping
                                                    // so we probably don't do anything here
                        break;                      // It's probably just the client wanting to pull data down.

                        case packetIDs.client_startSpectating:
                            Spectator.startSpectatingUser(PacketUser, CurrentPacket.data);
                        break;

                        case packetIDs.client_spectateFrames:
                            Spectator.sendSpectatorFrames(PacketUser, CurrentPacket.data);
                        break;

                        case packetIDs.client_stopSpectating:
                            Spectator.stopSpectatingUser(PacketUser);
                        break;

                        case packetIDs.client_sendPrivateMessage:
                            SendPrivateMessage(PacketUser, CurrentPacket);
                        break;

                        case packetIDs.client_joinLobby:
                            global.MultiplayerManager.userEnterLobby(PacketUser);
                        break;

                        case packetIDs.client_partLobby:
                            global.MultiplayerManager.userLeaveLobby(PacketUser);
                        break;

                        case packetIDs.client_createMatch:
                            global.MultiplayerManager.createMultiplayerMatch(PacketUser, CurrentPacket.data);
                        break;

                        case packetIDs.client_joinMatch:
                            global.MultiplayerManager.joinMultiplayerMatch(PacketUser, CurrentPacket.data);
                        break;

                        case packetIDs.client_matchChangeSlot:
                            PacketUser.currentMatch.moveToSlot(PacketUser, CurrentPacket.data);
                        break;

                        case packetIDs.client_matchReady:
                            PacketUser.currentMatch.setReadyState(PacketUser, true);
                        break;

                        case packetIDs.client_matchChangeSettings:
                            PacketUser.currentMatch.updateMatch(CurrentPacket.data);
                        break;

                        case packetIDs.client_matchNotReady:
                            PacketUser.currentMatch.setReadyState(PacketUser, false);
                        break;

                        case packetIDs.client_partMatch:
                            global.MultiplayerManager.leaveMultiplayerMatch(PacketUser);
                        break;

                        // Also handles user kick if the slot has a user
                        case packetIDs.client_matchLock:
                            PacketUser.currentMatch.lockMatchSlot(PacketUser, CurrentPacket.data);
                        break;

                        case packetIDs.client_matchNoBeatmap:
                            PacketUser.currentMatch.missingBeatmap(PacketUser);
                        break;

                        case packetIDs.client_matchSkipRequest:
                            PacketUser.currentMatch.matchSkip(PacketUser);
                        break;
                        
                        case packetIDs.client_matchHasBeatmap:
                            PacketUser.currentMatch.notMissingBeatmap(PacketUser);
                        break;

                        case packetIDs.client_matchTransferHost:
                            PacketUser.currentMatch.transferHost(CurrentPacket.data);
                        break;

                        case packetIDs.client_matchChangeMods:
                            PacketUser.currentMatch.updateMods(PacketUser, CurrentPacket.data);
                        break;

                        case packetIDs.client_matchStart:
                            PacketUser.currentMatch.startMatch();
                        break;

                        case packetIDs.client_matchLoadComplete:
                            PacketUser.currentMatch.matchPlayerLoaded(PacketUser);
                        break;

                        case packetIDs.client_matchComplete:
                            PacketUser.currentMatch.onPlayerFinishMatch(PacketUser);
                        break;

                        case packetIDs.client_matchScoreUpdate:
                            PacketUser.currentMatch.updatePlayerScore(PacketUser, CurrentPacket.data);
                        break;

                        case packetIDs.client_matchFailed:
                            PacketUser.currentMatch.matchFailed(PacketUser);
                        break;

                        case packetIDs.client_matchChangeTeam:
                            PacketUser.currentMatch.changeTeam(PacketUser);
                        break;

                        case packetIDs.client_channelJoin:
                            ChannelJoin(PacketUser, CurrentPacket.data);
                        break;

                        case packetIDs.client_channelPart:
                            ChannelPart(PacketUser, CurrentPacket.data);
                        break;

                        case packetIDs.client_friendAdd:
                            AddFriend(PacketUser, CurrentPacket.data);
                        break;

                        case packetIDs.client_friendRemove:
                            RemoveFriend(PacketUser, CurrentPacket.data);
                        break;

                        case packetIDs.client_userStatsRequest:
                            UserStatsRequest(PacketUser, CurrentPacket.data);
                        break;

                        case packetIDs.client_specialMatchInfoRequest:
                            TourneyMatchSpecialInfo(PacketUser, CurrentPacket.data);
                        break;

                        case packetIDs.client_specialJoinMatchChannel:
                            TourneyMatchJoinChannel(PacketUser, CurrentPacket.data);
                        break;

                        case packetIDs.client_specialLeaveMatchChannel:
                            TourneyMatchLeaveChannel(PacketUser, CurrentPacket.data);
                        break;

                        case packetIDs.client_invite:
                            MultiplayerInvite(PacketUser, CurrentPacket.data);
                        break;

                        case packetIDs.client_userPresenceRequest:
                            UserPresence(PacketUser, PacketUser.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;
                    }

                    // Concat current user queue into response data
                    responseData = Buffer.concat([responseData, PacketUser.queue], responseData.length + PacketUser.queue.length);
                    PacketUser.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": global.protocolVersion,
                "Connection": "keep-alive",
                "Keep-Alive": "timeout=5, max=100",
                "Content-Type": "text/html; charset=UTF-8"
            });
            res.end(responseData);
        }
    }
};