chore: add round-robin match repair script
This commit is contained in:
1 parent
ade5735dc2
commit
1272c81fa9
1 file changed
+680
+680
@@ -0,0 +1,680 @@
|
||||
import 'reflect-metadata';
|
||||
import { Module } from '@nestjs/common';
|
||||
import { ConfigModule } from '@nestjs/config';
|
||||
import { NestFactory } from '@nestjs/core';
|
||||
import mongoose from 'mongoose';
|
||||
import { readFile } from 'node:fs/promises';
|
||||
import { resolve } from 'node:path';
|
||||
import {
|
||||
ConnectionService,
|
||||
resolveMongoDbName,
|
||||
} from '../connection.service';
|
||||
import type {
|
||||
MatchDocument,
|
||||
MatchGameAssignment,
|
||||
MatchGameResult,
|
||||
MatchSeriesResult,
|
||||
TournamentCodeDocument,
|
||||
} from '../schema';
|
||||
import { SecretModule } from '../../secret/secret.module';
|
||||
import { MatchStatsFragmentBuilder } from '../../../community-stats/match-stats-fragment.builder';
|
||||
import { MatchStatsRepository } from '../../../community-stats/match-stats.repository';
|
||||
import { MatchStatsService } from '../../../community-stats/match-stats.service';
|
||||
|
||||
interface CliOptions {
|
||||
dryRun: boolean;
|
||||
matchId: mongoose.Types.ObjectId;
|
||||
maxRounds: number;
|
||||
nodeEnv: string;
|
||||
}
|
||||
|
||||
interface ResultGamePlan {
|
||||
oldGameNumber: number;
|
||||
newGameNumber: number;
|
||||
roundNumber: number;
|
||||
teamAIndex: number;
|
||||
teamBIndex: number;
|
||||
game: MatchGameResult;
|
||||
}
|
||||
|
||||
interface RepairPlan {
|
||||
schedule: MatchGameAssignment[];
|
||||
gamePlans: ResultGamePlan[];
|
||||
seriesResults: MatchSeriesResult[];
|
||||
winnerTeamIndex?: number;
|
||||
usedCodeByOldGameNumber: Map<number, TournamentCodeDocument>;
|
||||
releasedCodes: TournamentCodeDocument[];
|
||||
}
|
||||
|
||||
@Module({
|
||||
imports: [
|
||||
ConfigModule.forRoot({
|
||||
isGlobal: true,
|
||||
envFilePath: [
|
||||
resolve(__dirname, '../../../../../../project.env'),
|
||||
resolve(process.cwd(), '../project.env'),
|
||||
resolve(process.cwd(), 'apps/project.env'),
|
||||
resolve(process.cwd(), 'project.env'),
|
||||
],
|
||||
}),
|
||||
SecretModule,
|
||||
],
|
||||
providers: [
|
||||
ConnectionService,
|
||||
MatchStatsFragmentBuilder,
|
||||
MatchStatsRepository,
|
||||
MatchStatsService,
|
||||
],
|
||||
})
|
||||
class RepairModule {}
|
||||
|
||||
async function loadMachineEnvFile() {
|
||||
const homeDir = process.env.HOME ?? process.env.USERPROFILE;
|
||||
if (!homeDir) return;
|
||||
|
||||
const machineEnvFile = resolve(homeDir, 'source/global-env-vars.txt');
|
||||
|
||||
try {
|
||||
const file = await readFile(machineEnvFile, 'utf8');
|
||||
for (const rawLine of file.split(/\r?\n/)) {
|
||||
const line = rawLine.trim();
|
||||
if (!line || line.startsWith('#')) continue;
|
||||
|
||||
const matched = line.match(/^([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*)$/);
|
||||
if (!matched) continue;
|
||||
|
||||
const [, key, rawValue] = matched;
|
||||
process.env[key] = rawValue.replace(/^["']|["']$/g, '');
|
||||
}
|
||||
} catch {
|
||||
// 로컬 machine env 파일이 없으면 그냥 지나간다.
|
||||
}
|
||||
}
|
||||
|
||||
function parseArgs(argv: string[]): CliOptions {
|
||||
let dryRun = true;
|
||||
let matchId: mongoose.Types.ObjectId | undefined;
|
||||
let maxRounds = 3;
|
||||
let nodeEnv = process.env.NODE_ENV ?? 'dev';
|
||||
|
||||
for (let index = 0; index < argv.length; index += 1) {
|
||||
const arg = argv[index];
|
||||
if (arg === '--apply') {
|
||||
dryRun = false;
|
||||
continue;
|
||||
}
|
||||
if (arg === '--dry-run') {
|
||||
dryRun = true;
|
||||
continue;
|
||||
}
|
||||
if (arg === '--match-id') {
|
||||
const value = argv[index + 1];
|
||||
if (!value || !mongoose.isValidObjectId(value)) {
|
||||
throw new Error('--match-id requires a valid ObjectId.');
|
||||
}
|
||||
matchId = new mongoose.Types.ObjectId(value);
|
||||
index += 1;
|
||||
continue;
|
||||
}
|
||||
if (arg.startsWith('--match-id=')) {
|
||||
const value = arg.slice('--match-id='.length);
|
||||
if (!mongoose.isValidObjectId(value)) {
|
||||
throw new Error('--match-id requires a valid ObjectId.');
|
||||
}
|
||||
matchId = new mongoose.Types.ObjectId(value);
|
||||
continue;
|
||||
}
|
||||
if (arg === '--max-rounds') {
|
||||
maxRounds = parsePositiveInteger(argv[index + 1], '--max-rounds');
|
||||
index += 1;
|
||||
continue;
|
||||
}
|
||||
if (arg.startsWith('--max-rounds=')) {
|
||||
maxRounds = parsePositiveInteger(
|
||||
arg.slice('--max-rounds='.length),
|
||||
'--max-rounds',
|
||||
);
|
||||
continue;
|
||||
}
|
||||
if (arg === '--env') {
|
||||
const value = argv[index + 1];
|
||||
if (!value) throw new Error('--env requires dev, staging, or prod.');
|
||||
nodeEnv = value;
|
||||
index += 1;
|
||||
continue;
|
||||
}
|
||||
if (arg.startsWith('--env=')) {
|
||||
nodeEnv = arg.slice('--env='.length);
|
||||
continue;
|
||||
}
|
||||
if (arg === '--help' || arg === '-h') {
|
||||
printHelp();
|
||||
process.exit(0);
|
||||
}
|
||||
throw new Error(`Unknown argument: ${arg}`);
|
||||
}
|
||||
|
||||
if (!matchId) throw new Error('--match-id is required.');
|
||||
if (!['dev', 'staging', 'prod'].includes(nodeEnv)) {
|
||||
throw new Error('--env must be dev, staging, or prod.');
|
||||
}
|
||||
|
||||
return { dryRun, matchId, maxRounds, nodeEnv };
|
||||
}
|
||||
|
||||
function parsePositiveInteger(value: string | undefined, label: string) {
|
||||
const parsed = Number(value);
|
||||
if (!Number.isInteger(parsed) || parsed < 1) {
|
||||
throw new Error(`${label} requires a positive integer.`);
|
||||
}
|
||||
return parsed;
|
||||
}
|
||||
|
||||
function printHelp() {
|
||||
console.log(`Usage:
|
||||
pnpm --filter api exec ts-node src/modules/global/database/migrations/repair-limited-round-robin-finished-match.ts --match-id <id> --max-rounds 3 --dry-run
|
||||
pnpm --filter api exec ts-node src/modules/global/database/migrations/repair-limited-round-robin-finished-match.ts --match-id <id> --max-rounds 3 --env prod --apply
|
||||
|
||||
Options:
|
||||
--match-id <id> Match ObjectId to repair.
|
||||
--max-rounds <n> Number of round-robin rounds to keep. Default: 3.
|
||||
--dry-run Print the repair plan without writing. Default.
|
||||
--apply Apply match, tournament code, and stats updates.
|
||||
--env <env> dev | staging | prod. Default: NODE_ENV or dev.
|
||||
`);
|
||||
}
|
||||
|
||||
async function main() {
|
||||
const options = parseArgs(process.argv.slice(2));
|
||||
process.env.NODE_ENV = options.nodeEnv;
|
||||
await loadMachineEnvFile();
|
||||
|
||||
const app = await NestFactory.createApplicationContext(RepairModule, {
|
||||
logger: ['log', 'warn', 'error'],
|
||||
});
|
||||
|
||||
try {
|
||||
const connectionService = app.get(ConnectionService);
|
||||
const matchStatsService = app.get(MatchStatsService);
|
||||
const MatchModel = await connectionService.getModel('match');
|
||||
const TournamentCodeModel =
|
||||
await connectionService.getModel('tournamentCode');
|
||||
const match = await MatchModel.findById(options.matchId).exec();
|
||||
if (!match) {
|
||||
throw new Error(`Match not found: ${options.matchId.toString()}`);
|
||||
}
|
||||
|
||||
const codes = await TournamentCodeModel.find({
|
||||
_id: { $in: match.tournamentCodeIds ?? [] },
|
||||
})
|
||||
.sort({ gameNumber: 1, reservedAt: 1, _id: 1 })
|
||||
.exec();
|
||||
const plan = buildRepairPlan(match, codes, options.maxRounds);
|
||||
|
||||
printPlan(options, match, codes, plan);
|
||||
|
||||
if (options.dryRun) {
|
||||
console.log('No writes were made. Re-run with --apply to update MongoDB.');
|
||||
return;
|
||||
}
|
||||
|
||||
const now = new Date();
|
||||
const session = await (await connectionService.getConnection()).startSession();
|
||||
try {
|
||||
await session.withTransaction(async () => {
|
||||
await applyTournamentCodeUpdates(plan, now, session);
|
||||
await MatchModel.updateOne(
|
||||
{ _id: match._id },
|
||||
{
|
||||
$set: {
|
||||
status: 'finished',
|
||||
roundRobinMaxRounds: options.maxRounds,
|
||||
gameSchedule: plan.schedule,
|
||||
tournamentCodeIds: [
|
||||
...plan.usedCodeByOldGameNumber.values(),
|
||||
].map((code) => code._id),
|
||||
resultPollState: {
|
||||
startedAt: match.resultPollState?.startedAt ?? now,
|
||||
lastPolledAt: now,
|
||||
lastPollOutcome: 'matched',
|
||||
matchedCount: plan.gamePlans.length,
|
||||
expandedToAllPuuids: true,
|
||||
state: 'complete',
|
||||
},
|
||||
result: {
|
||||
winnerTeamIndex: plan.winnerTeamIndex,
|
||||
mvpUserId: match.result?.mvpUserId,
|
||||
riotMatchIds: plan.gamePlans.map(
|
||||
(gamePlan) => gamePlan.game.riotMatchId,
|
||||
),
|
||||
games: plan.gamePlans.map((gamePlan) => ({
|
||||
...toPlainGame(gamePlan.game),
|
||||
gameNumber: gamePlan.newGameNumber,
|
||||
})),
|
||||
seriesResults: plan.seriesResults,
|
||||
},
|
||||
},
|
||||
},
|
||||
{ session },
|
||||
).exec();
|
||||
});
|
||||
} finally {
|
||||
await session.endSession();
|
||||
}
|
||||
|
||||
await matchStatsService.buildAndUpsert(match._id);
|
||||
console.log('Repair applied and match stats rebuilt.');
|
||||
} finally {
|
||||
await app.close();
|
||||
await mongoose.disconnect();
|
||||
}
|
||||
}
|
||||
|
||||
function buildRepairPlan(
|
||||
match: MatchDocument,
|
||||
codes: TournamentCodeDocument[],
|
||||
maxRounds: number,
|
||||
): RepairPlan {
|
||||
if (match.gameMode !== 'round-robin') {
|
||||
throw new Error(`Expected round-robin match, got ${match.gameMode}.`);
|
||||
}
|
||||
|
||||
const games = [...(match.result?.games ?? [])]
|
||||
.map(toPlainGame)
|
||||
.sort((left, right) => left.gameNumber - right.gameNumber);
|
||||
if (games.length === 0) {
|
||||
throw new Error('Match has no result games to preserve.');
|
||||
}
|
||||
|
||||
const teamIndexes = [...new Set(match.teams.map((team) => team.teamIndex))]
|
||||
.filter((teamIndex) => Number.isInteger(teamIndex) && teamIndex > 0)
|
||||
.sort((left, right) => left - right);
|
||||
if (teamIndexes.length < 2) {
|
||||
throw new Error('Match needs at least two teams.');
|
||||
}
|
||||
if (teamIndexes.length % 2 !== 0) {
|
||||
throw new Error('This repair script currently expects an even team count.');
|
||||
}
|
||||
|
||||
const gamesPerRound = teamIndexes.length / 2;
|
||||
const requiredGames = gamesPerRound * maxRounds;
|
||||
if (games.length !== requiredGames) {
|
||||
throw new Error(
|
||||
`Expected ${requiredGames} result games for ${maxRounds} rounds and ${teamIndexes.length} teams, got ${games.length}.`,
|
||||
);
|
||||
}
|
||||
|
||||
validateResultGames(games, teamIndexes);
|
||||
const rounds = partitionIntoRounds(games, teamIndexes, maxRounds);
|
||||
const gamePlans = rounds.flatMap((roundGames, roundIndex) =>
|
||||
sortRoundGames(roundGames).map((game, gameIndex) => ({
|
||||
oldGameNumber: game.gameNumber,
|
||||
newGameNumber: roundIndex * gamesPerRound + gameIndex + 1,
|
||||
roundNumber: roundIndex + 1,
|
||||
teamAIndex: Math.min(game.blueTeamIndex, game.redTeamIndex),
|
||||
teamBIndex: Math.max(game.blueTeamIndex, game.redTeamIndex),
|
||||
game,
|
||||
})),
|
||||
);
|
||||
|
||||
const schedule = gamePlans.map(
|
||||
({ newGameNumber, roundNumber, teamAIndex, teamBIndex }) => ({
|
||||
gameNumber: newGameNumber,
|
||||
roundNumber,
|
||||
teamAIndex,
|
||||
teamBIndex,
|
||||
}),
|
||||
);
|
||||
|
||||
const usedOldGameNumbers = new Set(
|
||||
gamePlans.map((gamePlan) => gamePlan.oldGameNumber),
|
||||
);
|
||||
const usedCodeByOldGameNumber = resolveUsedCodesByOldGameNumber(
|
||||
codes,
|
||||
gamePlans,
|
||||
);
|
||||
const releasedCodes = codes.filter(
|
||||
(code) => !usedOldGameNumbers.has(code.gameNumber ?? 0),
|
||||
);
|
||||
const unsafeReleased = releasedCodes.filter((code) => code.state === 'used');
|
||||
if (unsafeReleased.length > 0) {
|
||||
throw new Error(
|
||||
`Refusing to release used tournament codes without matching result games: ${unsafeReleased
|
||||
.map((code) => formatCode(code))
|
||||
.join(', ')}`,
|
||||
);
|
||||
}
|
||||
|
||||
const updatedGames = gamePlans.map((gamePlan) => ({
|
||||
...toPlainGame(gamePlan.game),
|
||||
gameNumber: gamePlan.newGameNumber,
|
||||
}));
|
||||
const seriesResults = buildSeriesResults(updatedGames);
|
||||
|
||||
return {
|
||||
schedule,
|
||||
gamePlans,
|
||||
seriesResults,
|
||||
winnerTeamIndex: resolveMatchWinnerTeamIndex(seriesResults),
|
||||
usedCodeByOldGameNumber,
|
||||
releasedCodes,
|
||||
};
|
||||
}
|
||||
|
||||
function validateResultGames(games: MatchGameResult[], teamIndexes: number[]) {
|
||||
const validTeamIndexes = new Set(teamIndexes);
|
||||
const pairKeys = new Set<string>();
|
||||
const gameNumbers = new Set<number>();
|
||||
|
||||
for (const game of games) {
|
||||
if (gameNumbers.has(game.gameNumber)) {
|
||||
throw new Error(`Duplicate result gameNumber: ${game.gameNumber}.`);
|
||||
}
|
||||
gameNumbers.add(game.gameNumber);
|
||||
|
||||
if (!validTeamIndexes.has(game.blueTeamIndex)) {
|
||||
throw new Error(`Invalid blueTeamIndex ${game.blueTeamIndex}.`);
|
||||
}
|
||||
if (!validTeamIndexes.has(game.redTeamIndex)) {
|
||||
throw new Error(`Invalid redTeamIndex ${game.redTeamIndex}.`);
|
||||
}
|
||||
if (game.blueTeamIndex === game.redTeamIndex) {
|
||||
throw new Error(`Game ${game.gameNumber} has the same team twice.`);
|
||||
}
|
||||
|
||||
const key = pairKey(game);
|
||||
if (pairKeys.has(key)) {
|
||||
throw new Error(`Duplicate team pair in results: ${key}.`);
|
||||
}
|
||||
pairKeys.add(key);
|
||||
}
|
||||
}
|
||||
|
||||
function partitionIntoRounds(
|
||||
games: MatchGameResult[],
|
||||
teamIndexes: number[],
|
||||
maxRounds: number,
|
||||
): MatchGameResult[][] {
|
||||
const targetPerRound = teamIndexes.length / 2;
|
||||
const unused = new Set(games.map((game) => game.gameNumber));
|
||||
const byGameNumber = new Map(games.map((game) => [game.gameNumber, game]));
|
||||
const rounds: MatchGameResult[][] = [];
|
||||
|
||||
function fillRound(roundIndex: number): boolean {
|
||||
if (roundIndex === maxRounds) return unused.size === 0;
|
||||
|
||||
const candidates = enumerateRoundCandidates(
|
||||
[...unused]
|
||||
.map((gameNumber) => byGameNumber.get(gameNumber))
|
||||
.filter((game): game is MatchGameResult => Boolean(game)),
|
||||
teamIndexes,
|
||||
targetPerRound,
|
||||
);
|
||||
|
||||
for (const candidate of candidates) {
|
||||
for (const game of candidate) unused.delete(game.gameNumber);
|
||||
rounds[roundIndex] = candidate;
|
||||
if (fillRound(roundIndex + 1)) return true;
|
||||
for (const game of candidate) unused.add(game.gameNumber);
|
||||
}
|
||||
|
||||
rounds.length = roundIndex;
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!fillRound(0)) {
|
||||
throw new Error('Could not partition result games into simultaneous rounds.');
|
||||
}
|
||||
|
||||
return rounds;
|
||||
}
|
||||
|
||||
function enumerateRoundCandidates(
|
||||
availableGames: MatchGameResult[],
|
||||
teamIndexes: number[],
|
||||
targetPerRound: number,
|
||||
): MatchGameResult[][] {
|
||||
const candidates: MatchGameResult[][] = [];
|
||||
|
||||
function visit(usedTeams: Set<number>, chosen: MatchGameResult[]) {
|
||||
if (chosen.length === targetPerRound) {
|
||||
candidates.push([...chosen]);
|
||||
return;
|
||||
}
|
||||
|
||||
const nextTeam = teamIndexes.find((teamIndex) => !usedTeams.has(teamIndex));
|
||||
if (!nextTeam) return;
|
||||
|
||||
const nextGames = availableGames
|
||||
.filter((game) => {
|
||||
if (!includesTeam(game, nextTeam)) return false;
|
||||
return (
|
||||
!usedTeams.has(game.blueTeamIndex) &&
|
||||
!usedTeams.has(game.redTeamIndex)
|
||||
);
|
||||
})
|
||||
.sort((left, right) => left.gameNumber - right.gameNumber);
|
||||
|
||||
for (const game of nextGames) {
|
||||
chosen.push(game);
|
||||
usedTeams.add(game.blueTeamIndex);
|
||||
usedTeams.add(game.redTeamIndex);
|
||||
visit(usedTeams, chosen);
|
||||
usedTeams.delete(game.blueTeamIndex);
|
||||
usedTeams.delete(game.redTeamIndex);
|
||||
chosen.pop();
|
||||
}
|
||||
}
|
||||
|
||||
visit(new Set<number>(), []);
|
||||
return candidates;
|
||||
}
|
||||
|
||||
function sortRoundGames(games: MatchGameResult[]) {
|
||||
return [...games].sort(
|
||||
(left, right) =>
|
||||
Math.min(left.blueTeamIndex, left.redTeamIndex) -
|
||||
Math.min(right.blueTeamIndex, right.redTeamIndex) ||
|
||||
Math.max(left.blueTeamIndex, left.redTeamIndex) -
|
||||
Math.max(right.blueTeamIndex, right.redTeamIndex),
|
||||
);
|
||||
}
|
||||
|
||||
function resolveUsedCodesByOldGameNumber(
|
||||
codes: TournamentCodeDocument[],
|
||||
gamePlans: ResultGamePlan[],
|
||||
): Map<number, TournamentCodeDocument> {
|
||||
const byGameNumber = new Map<number, TournamentCodeDocument[]>();
|
||||
for (const code of codes) {
|
||||
if (!code.gameNumber) continue;
|
||||
const existing = byGameNumber.get(code.gameNumber) ?? [];
|
||||
existing.push(code);
|
||||
byGameNumber.set(code.gameNumber, existing);
|
||||
}
|
||||
|
||||
const result = new Map<number, TournamentCodeDocument>();
|
||||
for (const gamePlan of gamePlans) {
|
||||
const candidates = byGameNumber.get(gamePlan.oldGameNumber) ?? [];
|
||||
if (candidates.length !== 1) {
|
||||
throw new Error(
|
||||
`Expected exactly one tournament code for old game ${gamePlan.oldGameNumber}, got ${candidates.length}.`,
|
||||
);
|
||||
}
|
||||
const [code] = candidates;
|
||||
if (code.riotMatchId && code.riotMatchId !== gamePlan.game.riotMatchId) {
|
||||
throw new Error(
|
||||
`Tournament code ${formatCode(code)} has riotMatchId ${code.riotMatchId}, expected ${gamePlan.game.riotMatchId}.`,
|
||||
);
|
||||
}
|
||||
result.set(gamePlan.oldGameNumber, code);
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
async function applyTournamentCodeUpdates(
|
||||
plan: RepairPlan,
|
||||
now: Date,
|
||||
session: mongoose.ClientSession,
|
||||
) {
|
||||
const usedOperations = plan.gamePlans.map((gamePlan) => {
|
||||
const code = plan.usedCodeByOldGameNumber.get(gamePlan.oldGameNumber);
|
||||
if (!code) {
|
||||
throw new Error(`Missing tournament code for ${gamePlan.oldGameNumber}.`);
|
||||
}
|
||||
return code.updateOne(
|
||||
{
|
||||
$set: {
|
||||
state: 'used',
|
||||
gameNumber: gamePlan.newGameNumber,
|
||||
riotMatchId: gamePlan.game.riotMatchId,
|
||||
usedAt: resolveGameEndedAt(gamePlan.game),
|
||||
},
|
||||
$unset: {
|
||||
releasedAt: '',
|
||||
},
|
||||
},
|
||||
{ session },
|
||||
);
|
||||
});
|
||||
|
||||
const releasedOperations = plan.releasedCodes.map((code) =>
|
||||
code.updateOne(
|
||||
{
|
||||
$set: {
|
||||
state: 'released',
|
||||
releasedAt: now,
|
||||
},
|
||||
$unset: {
|
||||
matchId: '',
|
||||
gameNumber: '',
|
||||
reservedAt: '',
|
||||
usedAt: '',
|
||||
riotMatchId: '',
|
||||
},
|
||||
},
|
||||
{ session },
|
||||
),
|
||||
);
|
||||
|
||||
await Promise.all([...usedOperations, ...releasedOperations]);
|
||||
}
|
||||
|
||||
function buildSeriesResults(games: MatchGameResult[]): MatchSeriesResult[] {
|
||||
const bySeries = new Map<string, MatchSeriesResult>();
|
||||
for (const game of games) {
|
||||
const teamAIndex = Math.min(game.blueTeamIndex, game.redTeamIndex);
|
||||
const teamBIndex = Math.max(game.blueTeamIndex, game.redTeamIndex);
|
||||
const key = `${teamAIndex}:${teamBIndex}`;
|
||||
const current =
|
||||
bySeries.get(key) ??
|
||||
({
|
||||
teamAIndex,
|
||||
teamBIndex,
|
||||
teamAWins: 0,
|
||||
teamBWins: 0,
|
||||
} satisfies MatchSeriesResult);
|
||||
if (game.winnerTeamIndex === teamAIndex) current.teamAWins += 1;
|
||||
if (game.winnerTeamIndex === teamBIndex) current.teamBWins += 1;
|
||||
current.winnerTeamIndex =
|
||||
current.teamAWins > current.teamBWins
|
||||
? teamAIndex
|
||||
: current.teamBWins > current.teamAWins
|
||||
? teamBIndex
|
||||
: undefined;
|
||||
bySeries.set(key, current);
|
||||
}
|
||||
return [...bySeries.values()].sort(
|
||||
(left, right) =>
|
||||
left.teamAIndex - right.teamAIndex ||
|
||||
left.teamBIndex - right.teamBIndex,
|
||||
);
|
||||
}
|
||||
|
||||
function resolveMatchWinnerTeamIndex(seriesResults: MatchSeriesResult[]) {
|
||||
const winsByTeam = new Map<number, number>();
|
||||
for (const series of seriesResults) {
|
||||
if (!series.winnerTeamIndex) continue;
|
||||
winsByTeam.set(
|
||||
series.winnerTeamIndex,
|
||||
(winsByTeam.get(series.winnerTeamIndex) ?? 0) + 1,
|
||||
);
|
||||
}
|
||||
|
||||
const sorted = [...winsByTeam.entries()].sort(
|
||||
(left, right) => right[1] - left[1],
|
||||
);
|
||||
if (sorted.length === 0) return undefined;
|
||||
if (sorted.length > 1 && sorted[0][1] === sorted[1][1]) return undefined;
|
||||
return sorted[0][0];
|
||||
}
|
||||
|
||||
function printPlan(
|
||||
options: CliOptions,
|
||||
match: MatchDocument,
|
||||
codes: TournamentCodeDocument[],
|
||||
plan: RepairPlan,
|
||||
) {
|
||||
console.log(
|
||||
`[limited round-robin repair] mode=${options.dryRun ? 'dry-run' : 'apply'} env=${options.nodeEnv} db=${resolveMongoDbName(options.nodeEnv)}`,
|
||||
);
|
||||
console.log(
|
||||
`[limited round-robin repair] match=${match._id.toString()} title="${match.title}"`,
|
||||
);
|
||||
console.log(
|
||||
`[limited round-robin repair] status ${match.status} -> finished, maxRounds=${options.maxRounds}`,
|
||||
);
|
||||
console.log(
|
||||
`[limited round-robin repair] resultGames=${plan.gamePlans.length} codes kept=${plan.usedCodeByOldGameNumber.size} codes released=${plan.releasedCodes.length} previousCodeIds=${codes.length}`,
|
||||
);
|
||||
console.log(
|
||||
`[limited round-robin repair] winnerTeamIndex=${plan.winnerTeamIndex ?? '(tie)'}`,
|
||||
);
|
||||
|
||||
for (const gamePlan of plan.gamePlans) {
|
||||
console.log(
|
||||
` R${gamePlan.roundNumber} G${gamePlan.newGameNumber}: ${gamePlan.teamAIndex}팀 vs ${gamePlan.teamBIndex}팀 (old G${gamePlan.oldGameNumber}, riot=${gamePlan.game.riotMatchId})`,
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
function toPlainGame(game: MatchGameResult): MatchGameResult {
|
||||
const maybeSubdocument = game as unknown as {
|
||||
toObject?: () => MatchGameResult;
|
||||
};
|
||||
const objectValue =
|
||||
typeof maybeSubdocument.toObject === 'function'
|
||||
? maybeSubdocument.toObject()
|
||||
: game;
|
||||
return {
|
||||
...objectValue,
|
||||
participants: [...(objectValue.participants ?? [])],
|
||||
};
|
||||
}
|
||||
|
||||
function includesTeam(game: MatchGameResult, teamIndex: number) {
|
||||
return game.blueTeamIndex === teamIndex || game.redTeamIndex === teamIndex;
|
||||
}
|
||||
|
||||
function pairKey(game: MatchGameResult) {
|
||||
const teamAIndex = Math.min(game.blueTeamIndex, game.redTeamIndex);
|
||||
const teamBIndex = Math.max(game.blueTeamIndex, game.redTeamIndex);
|
||||
return `${teamAIndex}:${teamBIndex}`;
|
||||
}
|
||||
|
||||
function resolveGameEndedAt(game: MatchGameResult) {
|
||||
return new Date(game.gameCreation + game.gameDuration * 1000);
|
||||
}
|
||||
|
||||
function formatCode(code: TournamentCodeDocument) {
|
||||
return `${code._id.toString()}(gameNumber=${code.gameNumber ?? 'none'}, state=${code.state})`;
|
||||
}
|
||||
|
||||
void main()
|
||||
.then(() => {
|
||||
process.exit(0);
|
||||
})
|
||||
.catch((error: unknown) => {
|
||||
console.error(error instanceof Error ? error.message : error);
|
||||
process.exit(1);
|
||||
});
|
||||
Reference in new issue
Block a user