Binato/server/objects/Match.ts

693 lines
19 KiB
TypeScript

import Channel from "./Channel";
import Shared from "../objects/Shared";
import DataStream from "./DataStream";
import Slot from "./Slot";
import User from "./User";
import StatusUpdate from "../packets/StatusUpdate";
import { SlotStatus } from "../enums/SlotStatus";
import MatchData from "../interfaces/packetTypes/MatchData";
import { Team } from "../enums/Team";
import MatchStartSkipData from "../interfaces/packetTypes/MatchStartSkipData";
import { Mods } from "../enums/Mods";
import PlayerScore from "../interfaces/PlayerScore";
import { enumHasFlag } from "../Util";
import osu from "../../osuTyping";
import ScoreFrameData from "../interfaces/packetTypes/ScoreFrameData";
// Mods which need to be applied to the match during freemod.
const matchFreemodGlobalMods:Array<Mods> = [
Mods.DoubleTime, Mods.Nightcore, Mods.HalfTime
]
export default class Match {
// osu! Data
public matchId:number = -1;
public inProgress:boolean = false;
public matchType:number = 0;
public activeMods:number = 0;
public gameName:string = "";
public gamePassword?:string;
public beatmapName:string = '';
public beatmapId:number = 0;
public beatmapChecksum:string = '';
public slots:Array<Slot> = new Array<Slot>();
public host:User;
public playMode:number = 0;
public matchScoringType:number = 0;
public matchTeamType:number = 0;
public specialModes:number = 0;
public seed:number = 0;
// Binato data
public roundId:number = 0;
public matchStartCountdownActive:boolean = false;
public matchStream:DataStream;
public matchChatChannel:Channel;
public matchLoadSlots?:Array<MatchStartSkipData>;
public matchSkippedSlots?:Array<MatchStartSkipData>;
public playerScores?:Array<PlayerScore>;
public countdownTime:number = 0;
public countdownTimer?:NodeJS.Timeout;
private serialisedMatchJSON:MatchData;
private readonly shared:Shared;
private constructor(matchData:MatchData, shared:Shared) {
this.shared = shared;
this.matchId = matchData.matchId;
this.inProgress = matchData.inProgress;
this.matchType = matchData.matchType;
this.activeMods = matchData.activeMods;
this.gameName = matchData.gameName;
if (matchData.gamePassword == '') matchData.gamePassword == null;
this.gamePassword = matchData.gamePassword;
this.beatmapName = matchData.beatmapName;
this.beatmapId = matchData.beatmapId;
this.beatmapChecksum = matchData.beatmapChecksum;
for (let i = 0; i < matchData.slots.length; i++) {
const slot = matchData.slots[i];
if (slot.playerId === -1) {
this.slots.push(new Slot(i, slot.status, slot.team, undefined, slot.mods));
} else {
this.slots.push(new Slot(i, slot.status, slot.team, shared.users.getById(slot.playerId), slot.mods));
}
}
const hostUser = shared.users.getById(matchData.host);
if (hostUser === undefined) {
// NOTE: This should never be possible to hit
// since this user JUST made the match.
throw "Host User of match was undefined";
}
this.host = hostUser;
this.playMode = matchData.playMode;
this.matchScoringType = matchData.matchScoringType;
this.matchTeamType = matchData.matchTeamType;
this.specialModes = matchData.specialModes;
this.seed = matchData.seed;
this.matchStream = shared.streams.CreateStream(`multiplayer:match_${this.matchId}`, false);
this.matchChatChannel = shared.chatManager.AddSpecialChatChannel("multiplayer", `mp_${this.matchId}`);
this.serialisedMatchJSON = matchData;
//this.multiplayerExtras = null;
//this.isTourneyMatch = false;
//this.tourneyClientUsers = [];
}
public static createMatch(matchHost:User, matchData:MatchData, shared:Shared) : Promise<Match> {
return new Promise<Match>(async (resolve, reject) => {
try {
matchData.matchId = (await shared.database.query(
"INSERT INTO mp_matches (id, name, open_time, close_time, seed) VALUES (NULL, ?, UNIX_TIMESTAMP(), NULL, ?) RETURNING id;",
[matchData.gameName, matchData.seed]
))[0]["id"];
const matchInstance = new Match(matchData, shared);
// Update the status of the current user
StatusUpdate(matchHost, matchHost.id);
const osuPacketWriter = osu.Bancho.Writer();
osuPacketWriter.MatchNew(matchInstance.serialiseMatch());
matchHost.addActionToQueue(osuPacketWriter.toBuffer);
shared.multiplayerManager.UpdateLobbyListing();
resolve(matchInstance);
} catch (e) {
reject(e);
}
});
}
// Convert class data back to a format that osu-packet can understand
public serialiseMatch() : MatchData {
const matchDataRef = this.serialisedMatchJSON;
matchDataRef.matchId = this.matchId;
matchDataRef.matchType = this.matchType;
matchDataRef.activeMods = this.activeMods;
matchDataRef.gameName = this.gameName;
matchDataRef.gamePassword = this.gamePassword ?? "";
matchDataRef.inProgress = this.inProgress;
matchDataRef.beatmapName = this.beatmapName;
matchDataRef.beatmapId = this.beatmapId;
matchDataRef.beatmapChecksum = this.beatmapChecksum;
matchDataRef.host = this.host.id;
matchDataRef.playMode = this.playMode;
matchDataRef.matchScoringType = this.matchScoringType;
matchDataRef.matchTeamType = this.matchTeamType;
matchDataRef.specialModes = this.specialModes;
matchDataRef.seed = this.seed;
for (let i = 0; i < this.slots.length; i++) {
const slot = this.slots[i];
const osuSlot = this.serialisedMatchJSON.slots[i];
osuSlot.status = slot.status;
osuSlot.team = slot.team;
osuSlot.mods = slot.mods;
if (slot.player instanceof User) {
osuSlot.playerId = slot.player.id;
} else {
osuSlot.playerId = -1;
}
}
return this.serialisedMatchJSON;
}
public leaveMatch(user:User) {
// Make sure this leave call is valid
if (!user.inMatch || user.matchSlot === undefined) {
return;
}
// Set the slot's status to avaliable
user.matchSlot.status = SlotStatus.Empty;
user.matchSlot.team = 0;
user.matchSlot.player = undefined;
user.matchSlot.mods = 0;
// Remove the leaving user from the match's stream
this.matchStream.RemoveUser(user);
this.matchChatChannel.Leave(user);
// Send this after removing the user from match streams to avoid a leave notification for self?
this.sendMatchUpdate();
}
public async updateMatch(user:User, matchData:MatchData) {
// Update match with new data
this.inProgress = matchData.inProgress;
this.matchType = matchData.matchType;
this.activeMods = matchData.activeMods;
const gameNameChanged = this.gameName !== matchData.gameName;
this.gameName = matchData.gameName;
if (matchData.gamePassword === "") {
this.gamePassword = undefined;
} else {
this.gamePassword = matchData.gamePassword;
}
this.beatmapName = matchData.beatmapName;
this.beatmapId = matchData.beatmapId;
this.beatmapChecksum = matchData.beatmapChecksum;
if (matchData.host !== this.host.id) {
const hostUser = this.shared.users.getById(matchData.host);
if (hostUser === undefined) {
// NOTE: This should never be possible to hit
throw "Host User of match was undefined";
}
this.host = hostUser;
}
this.playMode = matchData.playMode;
this.matchScoringType = matchData.matchScoringType;
this.matchTeamType = matchData.matchTeamType;
this.specialModes = matchData.specialModes;
const gameSeedChanged = this.seed !== matchData.seed;
this.seed = matchData.seed;
if (gameNameChanged || gameSeedChanged) {
const queryData = [];
if (gameNameChanged) {
queryData.push(matchData.gameName);
}
if (gameSeedChanged) {
queryData.push(matchData.seed);
}
queryData.push(this.matchId);
await this.shared.database.execute(
`UPDATE mp_matches SET ${gameNameChanged ? `name = ?${gameSeedChanged ? ", " : ""}` : ""}${gameSeedChanged ? `seed = ?` : ""} WHERE id = ?`,
queryData
);
}
this.sendMatchUpdate();
// Update the match listing in the lobby to reflect these changes
this.shared.multiplayerManager.UpdateLobbyListing();
}
public sendMatchUpdate() {
const osuPacketWriter = osu.Bancho.Writer();
osuPacketWriter.MatchUpdate(this.serialiseMatch());
// Update all users in the match with new match information
this.matchStream.Send(osuPacketWriter.toBuffer);
}
public moveToSlot(user:User, slotToMoveTo:number) {
if (slotToMoveTo < 0 || slotToMoveTo >= this.slots.length) {
return;
}
const newSlot = this.slots[slotToMoveTo];
if (newSlot.status === SlotStatus.Locked || !(user.matchSlot instanceof Slot)) {
return;
}
user.matchSlot = newSlot.transferFrom(user.matchSlot);
this.sendMatchUpdate();
this.shared.multiplayerManager.UpdateLobbyListing();
}
public changeTeam(user:User) {
if (!(user.matchSlot instanceof Slot)) {
return;
}
user.matchSlot.team = user.matchSlot.team === Team.Red ? Team.Blue : Team.Red;
this.sendMatchUpdate();
}
public setStateReady(user:User) {
if (!(user.matchSlot instanceof Slot)) {
return;
}
user.matchSlot.status = SlotStatus.Ready;
this.sendMatchUpdate();
}
public setStateNotReady(user:User) {
if (!(user.matchSlot instanceof Slot)) {
return;
}
user.matchSlot.status = SlotStatus.NotReady;
this.sendMatchUpdate();
}
public lockOrKick(user:User, slotToActionOn:number) {
if (slotToActionOn < 0 || slotToActionOn >= 16) {
return;
}
// Make sure the user attempting to kick / lock is the host of the match
if (!User.Equals(user, this.host)) {
return;
}
const slot = this.slots[slotToActionOn];
if (slot.player instanceof User) { // Kick
const kickedPlayer = slot.player;
// Remove player's refs to the match & slot
kickedPlayer.match = undefined;
kickedPlayer.matchSlot = undefined;
// Nuke all slot properties
slot.reset();
// Kick player
this.shared.multiplayerManager.LeaveMatch(kickedPlayer);
this.sendMatchUpdate();
} else { // Lock / Unlock
slot.status = slot.status === SlotStatus.Empty ? SlotStatus.Locked : SlotStatus.Empty;
this.sendMatchUpdate();
}
this.shared.multiplayerManager.UpdateLobbyListing();
}
public missingBeatmap(user:User) {
const slot = user.matchSlot;
if (!(slot instanceof Slot)) {
return;
}
slot.status = SlotStatus.MissingBeatmap;
this.sendMatchUpdate();
}
public notMissingBeatmap(user:User) {
const slot = user.matchSlot;
if (!(slot instanceof Slot)) {
return;
}
slot.status = SlotStatus.NotReady;
this.sendMatchUpdate();
}
public matchSkip(user:User) {
if (this.matchSkippedSlots === undefined) {
this.matchSkippedSlots = new Array<MatchStartSkipData>();
for (const slot of this.slots) {
// Make sure the slot has a user in it
if (slot.player === undefined || slot.status === SlotStatus.Empty || slot.status === SlotStatus.Locked) {
continue;
}
// Add the slot's user to the loaded checking array
this.matchSkippedSlots.push({
playerId: slot.player?.id,
flag: false
});
}
}
let allSkipped = true;
for (const skippedSlot of this.matchSkippedSlots) {
// If loadslot belongs to this user then set loaded to true
if (skippedSlot.playerId === user.id) {
skippedSlot.flag = true;
}
if (skippedSlot.flag) continue;
// A user hasn't skipped
allSkipped = false;
}
const slotId = user.matchSlot?.slotId ?? Number.MIN_VALUE;
if (slotId === Number.MIN_VALUE) {
return;
}
// All players have finished playing, finish the match
if (allSkipped) {
const osuPacketWriter = osu.Bancho.Writer();
osuPacketWriter.MatchPlayerSkipped(slotId);
osuPacketWriter.MatchSkip();
this.matchStream.Send(osuPacketWriter.toBuffer);
this.matchSkippedSlots = undefined;
} else {
const osuPacketWriter = osu.Bancho.Writer();
osuPacketWriter.MatchPlayerSkipped(slotId);
this.matchStream.Send(osuPacketWriter.toBuffer);
}
}
public transferHost(user:User, slotIDToTransferTo:number) {
// Set the lobby's host to the new user
const newHost = this.slots[slotIDToTransferTo].player;
if (newHost instanceof User) {
this.host = newHost;
this.sendMatchUpdate();
}
}
public updateMods(user:User, mods:Mods) {
const slot = user.matchSlot;
if (!(slot instanceof Slot)) {
return;
}
// Check if freemod is enabled or not
if (this.specialModes === 1) {
slot.mods = mods;
// Extra check for host during freemod
if (User.Equals(this.host, user)) {
let generatedMatchModList = 0;
for (const mod of matchFreemodGlobalMods) {
if (enumHasFlag(slot.mods, mod)) {
slot.mods -= mod;
generatedMatchModList += mod;
}
}
this.activeMods = generatedMatchModList;
}
this.sendMatchUpdate();
} else {
if (!User.Equals(this.host, user)) {
return;
}
this.activeMods = mods;
this.sendMatchUpdate();
}
this.shared.multiplayerManager.UpdateLobbyListing();
}
startMatch() {
// Make sure the match is not already in progress
// The client sometimes double fires the start packet
if (this.inProgress) {
return;
}
this.inProgress = true;
this.matchLoadSlots = new Array<MatchStartSkipData>();
// Loop through all slots in the match
for (const slot of this.slots) {
// Make sure the slot has a user in it
if (slot.player === undefined || slot.status === SlotStatus.Empty || slot.status === SlotStatus.Locked) {
continue;
}
// Add the slot's user to the loaded checking array
this.matchLoadSlots.push({
playerId: slot.player?.id,
flag: false
});
// Set the user's status to playing
slot.status = 32;
}
const osuPacketWriter = osu.Bancho.Writer();
osuPacketWriter.MatchStart(this.serialiseMatch());
// Inform all users in the match that it has started
this.matchStream.Send(osuPacketWriter.toBuffer);
// Update all users in the match with new info
this.sendMatchUpdate();
// Update match listing in lobby to show the game is in progress
this.shared.multiplayerManager.UpdateLobbyListing();
}
public matchPlayerLoaded(user:User) {
if (this.matchLoadSlots === undefined) {
return;
}
let allLoaded = true;
for (const loadedSlot of this.matchLoadSlots) {
if (loadedSlot.playerId === user.id) {
loadedSlot.flag = true;
}
if (loadedSlot.flag) continue;
allLoaded = false;
}
// All players have loaded the beatmap, start playing.
if (allLoaded) {
const osuPacketWriter = osu.Bancho.Writer();
osuPacketWriter.MatchAllPlayersLoaded();
this.matchStream.Send(osuPacketWriter.toBuffer);
// Blank out user loading array
this.matchLoadSlots = undefined;
this.playerScores = new Array<PlayerScore>();
for (const slot of this.slots) {
if (slot.player === undefined || slot.status === SlotStatus.Empty || slot.status === SlotStatus.Locked) {
continue;
}
this.playerScores.push({
player: slot.player,
slot: slot,
score: 0,
isCurrentlyFailed: false,
hasFailed: false,
_raw: undefined,
});
}
}
}
public async onPlayerFinishMatch(user:User) {
if (this.matchLoadSlots === undefined) {
// Repopulate user loading slots again
this.matchLoadSlots = [];
for (const slot of this.slots) {
// Make sure the slot has a user
if (slot.player === undefined || slot.status === SlotStatus.Empty || slot.status === SlotStatus.Locked) {
continue;
}
// Populate user loading slots with this user's id and load status
this.matchLoadSlots.push({
playerId: slot.player?.id,
flag: false
});
}
}
let allLoaded = true;
for (const loadedSlot of this.matchLoadSlots) {
if (loadedSlot.playerId == user.id) {
loadedSlot.flag = true;
}
if (loadedSlot.flag) continue;
// A user hasn't finished playing
allLoaded = false;
}
// All players have finished playing, finish the match
if (allLoaded) {
await this.finishMatch();
}
}
public async finishMatch() {
if (!this.inProgress) {
return;
}
this.matchLoadSlots = undefined;
this.inProgress = false;
const osuPacketWriter = osu.Bancho.Writer();
const queryData:Array<string | number | null> = [
this.matchId,
this.roundId++,
this.playMode,
this.matchType,
this.matchScoringType,
this.matchTeamType,
this.activeMods,
this.beatmapChecksum,
(this.specialModes === 1) ? 1 : 0
];
if (this.playerScores === undefined) {
throw "playerScores was null in a place it really shouldn't have been!";
}
for (const slot of this.slots) {
// For every empty / locked slot push a null to the data array
if (slot.player === undefined || slot.status === SlotStatus.Empty || slot.status === SlotStatus.Locked) {
queryData.push(null);
continue;
}
for (const _playerScore of this.playerScores) {
if (_playerScore.player?.id === slot.player?.id && _playerScore._raw !== undefined) {
const score = _playerScore._raw;
queryData.push(`${slot.player?.id}|${score.totalScore}|${score.maxCombo}|${score.count300}|${score.count100}|${score.count50}|${score.countGeki}|${score.countKatu}|${score.countMiss}|${(score.currentHp == 254) ? 1 : 0}${(this.specialModes === 1) ? `|${slot.mods}` : ""}|${score.usingScoreV2 ? 1 : 0}${score.usingScoreV2 ? `|${score.comboPortion}|${score.bonusPortion}` : ""}`);
break;
}
}
slot.status = SlotStatus.NotReady;
}
await this.shared.database.execute("INSERT INTO mp_match_rounds (id, match_id, round_id, round_mode, match_type, round_scoring_type, round_team_type, round_mods, beatmap_md5, freemod, player0, player1, player2, player3, player4, player5, player6, player7, player8, player9, player10, player11, player12, player13, player14, player15) VALUES (NULL, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)", queryData);
osuPacketWriter.MatchComplete();
// Inform all users in the match that it is complete
this.matchStream.Send(osuPacketWriter.toBuffer);
// Update all users in the match with new info
this.sendMatchUpdate();
this.shared.multiplayerManager.UpdateLobbyListing();
// TODO: Re-implement multiplayer extras
//if (this.multiplayerExtras != null) this.multiplayerExtras.onMatchFinished(JSON.parse(JSON.stringify(this.playerScores)));
this.playerScores = undefined;
}
updatePlayerScore(user:User, scoreFrameData:ScoreFrameData) {
const osuPacketWriter = osu.Bancho.Writer();
if (user.matchSlot === undefined || user.matchSlot.player === undefined || this.playerScores === undefined) {
return;
}
scoreFrameData.id = user.matchSlot.slotId;
// Update playerScores
for (const playerScore of this.playerScores) {
if (playerScore.player?.id === user.id) {
playerScore.score = scoreFrameData.totalScore;
const isCurrentlyFailed = scoreFrameData.currentHp == 254;
playerScore.isCurrentlyFailed = isCurrentlyFailed;
if (!playerScore.hasFailed && isCurrentlyFailed) {
playerScore.hasFailed = true;
}
playerScore._raw = scoreFrameData;
break;
}
}
osuPacketWriter.MatchScoreUpdate(scoreFrameData);
// Send the newly updated score to all users in the match
this.matchStream.Send(osuPacketWriter.toBuffer);
}
matchFailed(user:User) {
const osuPacketWriter = osu.Bancho.Writer();
// Make sure the user is in the match in a valid slot
if (user.matchSlot === undefined) {
return;
}
osuPacketWriter.MatchPlayerFailed(user.id);
this.matchStream.Send(osuPacketWriter.toBuffer);
}
}