import { Injectable } from '@nestjs/common'; import mongoose from 'mongoose'; import type { MatchDocument, MatchGameResultParticipant, MatchStatsCheckpoint, MatchStatsItemBuildEvent, MatchStatsObjectiveEvent, MatchStatsObjectiveSummary, MatchStatsParticipantCheckpoints, MatchStatsSkillBuildEvent, MatchStatsTimelineEvent, MatchStatsTimelinePoint, TeamSide, } from '../global/database/schema'; import type { RiotMatchDto, RiotMatchParticipantDto, RiotMatchTimelineDto, } from '../riot/riot.types'; import type { InternalMatchCardView } from './community-stats.types'; import type { InternalGameDetail, InternalRecord, MatchStatsFragment, } from './match-stats.types'; interface ParticipantBuildEvents { items: MatchStatsItemBuildEvent[]; skills: MatchStatsSkillBuildEvent[]; } interface TimelineProjection { objectiveEvents: MatchStatsObjectiveEvent[]; timelineEvents: MatchStatsTimelineEvent[]; } @Injectable() export class MatchStatsFragmentBuilder { public buildFragment(params: { match: MatchDocument; rawByRiotMatchId: Map; timelineByRiotMatchId?: Map; }): MatchStatsFragment { const games = [...(params.match.result?.games ?? [])].sort( (left, right) => left.gameNumber - right.gameNumber, ); const matchCard = this.toMatchCard(params.match, games); const gameDetails = games.map((game) => { const raw = params.rawByRiotMatchId.get(game.riotMatchId); const timeline = params.timelineByRiotMatchId?.get(game.riotMatchId); return raw ? this.toGameDetail(params.match, game, raw, timeline) : this.toFallbackGameDetail(params.match, game); }); const records = gameDetails.flatMap((detail) => detail.teams.flatMap((team) => team.participants), ); const gameCreations = gameDetails.map((detail) => detail.gameCreation); return { matchCard, records, gameDetails, userIds: [ ...new Map( records .filter((record) => mongoose.isValidObjectId(record.userId)) .map((record) => [ record.userId, new mongoose.Types.ObjectId(record.userId), ]), ).values(), ], championIds: [...new Set(records.map((record) => record.championId))], gameCreationMin: gameCreations.length > 0 ? Math.min(...gameCreations) : params.match.scheduledAt.getTime(), gameCreationMax: gameCreations.length > 0 ? Math.max(...gameCreations) : params.match.scheduledAt.getTime(), }; } private toMatchCard( match: MatchDocument, games: NonNullable['games'], ): InternalMatchCardView { const participantById = new Map( match.participants.map((participant) => [ participant.userId.toString(), participant, ]), ); return { matchId: match._id.toString(), title: match.title, scheduledAt: match.scheduledAt.toISOString(), status: match.status === 'finished' ? 'finished' : 'in-progress', gameCount: match.gameCount, winnerTeamIndex: match.result?.winnerTeamIndex, seriesResults: match.result?.seriesResults ?? [], games: games.map((game) => ({ gameNumber: game.gameNumber, riotMatchId: game.riotMatchId ?? null, blueTeamIndex: game.blueTeamIndex, redTeamIndex: game.redTeamIndex, winnerTeamIndex: game.winnerTeamIndex ?? null, winnerSide: game.winnerSide ?? null, gameDuration: game.gameDuration, })), teams: match.teams.map((team) => ({ teamIndex: team.teamIndex, name: team.name, members: team.members.map((member) => { const participant = participantById.get(member.userId.toString()); return { userId: member.userId.toString(), summonerName: participant?.gameName ?? 'Unknown', profileIconId: participant?.profileIconId ?? 0, }; }), })), }; } private toGameDetail( match: MatchDocument, game: NonNullable['games'][number], raw: RiotMatchDto, timeline?: RiotMatchTimelineDto, ): InternalGameDetail { const usableTimeline = isUsableTimeline(timeline, raw.info.gameDuration) ? timeline : undefined; const puuidByUserId = new Map( match.participants .filter((participant) => participant.puuid) .map((participant) => [ participant.userId.toString(), participant.puuid as string, ]), ); const rawByPuuid = new Map( raw.info.participants.map((participant) => [ participant.puuid, participant, ]), ); const rawTeamIdBySide = new Map(); for (const participant of game.participants) { const puuid = puuidByUserId.get(participant.userId.toString()); const rawParticipant = puuid ? rawByPuuid.get(puuid) : undefined; if (rawParticipant) { rawTeamIdBySide.set(participant.side, rawParticipant.teamId); } } const sideByParticipantId = this.toSideByParticipantId( raw, rawTeamIdBySide, ); const { objectiveEvents, timelineEvents } = this.toTimelineEvents( usableTimeline, rawTeamIdBySide, sideByParticipantId, ); const timelineObjectives = this.toTimelineObjectives(objectiveEvents); const buildEventsByParticipantId = this.toBuildEventsByParticipantId(usableTimeline); const checkpointsByParticipantId = this.toCheckpointsByParticipantId( usableTimeline, raw.info.gameDuration, ); return { gameNumber: game.gameNumber, riotMatchId: game.riotMatchId, gameCreation: game.gameCreation, gameDuration: game.gameDuration, gameVersion: raw.info.gameVersion, winnerSide: game.winnerSide, timeline: this.toTimeline(raw, rawTeamIdBySide, usableTimeline), timelineLoaded: Boolean(usableTimeline), objectiveEvents, timelineEvents, teams: (['blue', 'red'] as TeamSide[]).map((side) => { const teamIndex = side === 'blue' ? game.blueTeamIndex : game.redTeamIndex; const rawTeamId = rawTeamIdBySide.get(side); const rawTeam = raw.info.teams.find( (team) => team.teamId === rawTeamId, ); const teamRawParticipants = raw.info.participants.filter( (participant) => participant.teamId === rawTeamId, ); const teamKills = teamRawParticipants.reduce( (sum, participant) => sum + participant.kills, 0, ); const teamDamage = teamRawParticipants.reduce( (sum, participant) => sum + participant.totalDamageDealtToChampions, 0, ); return { teamIndex, side, win: game.winnerSide === side, objectives: this.toObjectiveSummary( rawTeam, timelineObjectives.get(side), ), bans: (rawTeam?.bans ?? []).map((ban) => ({ championId: ban.championId, pickTurn: ban.pickTurn, })), participants: game.participants .filter((participant) => participant.side === side) .map((participant) => { const rawParticipant = rawByPuuid.get( puuidByUserId.get(participant.userId.toString()) ?? '', ); return this.toRecord({ match, game, participant, rawParticipant, buildEvents: rawParticipant ? buildEventsByParticipantId.get( rawParticipant.participantId, ) : undefined, checkpoints: rawParticipant ? checkpointsByParticipantId.get(rawParticipant.participantId) : undefined, teamKills, teamDamage, }); }), }; }), }; } private toFallbackGameDetail( match: MatchDocument, game: NonNullable['games'][number], ): InternalGameDetail { return { gameNumber: game.gameNumber, riotMatchId: game.riotMatchId, gameCreation: game.gameCreation, gameDuration: game.gameDuration, winnerSide: game.winnerSide, timeline: [], timelineLoaded: false, objectiveEvents: [], timelineEvents: [], teams: (['blue', 'red'] as TeamSide[]).map((side) => ({ teamIndex: side === 'blue' ? game.blueTeamIndex : game.redTeamIndex, side, win: game.winnerSide === side, objectives: emptyObjectives(), bans: [], participants: game.participants .filter((participant) => participant.side === side) .map((participant) => this.toRecord({ match, game, participant, teamKills: 0, teamDamage: 0, }), ), })), }; } private toRecord(params: { match: MatchDocument; game: NonNullable['games'][number]; participant: MatchGameResultParticipant; rawParticipant?: RiotMatchParticipantDto; buildEvents?: ParticipantBuildEvents; checkpoints?: MatchStatsParticipantCheckpoints; teamKills: number; teamDamage: number; }): InternalRecord { const { match, game, participant, rawParticipant, buildEvents, checkpoints, teamKills, teamDamage, } = params; const snapshot = match.participants.find((item) => item.userId.equals(participant.userId), ); const minutes = Math.max( (rawParticipant?.timePlayed ?? game.gameDuration) / 60, 1, ); const cs = rawParticipant ? rawParticipant.totalMinionsKilled + rawParticipant.neutralMinionsKilled : 0; const damage = rawParticipant?.totalDamageDealtToChampions ?? 0; const killParticipation = percent( participant.kills + participant.assists, teamKills, ); const damageShare = percent(damage, teamDamage); const rating = this.resolveRating({ kills: participant.kills, deaths: participant.deaths, assists: participant.assists, killParticipation, csPerMin: average(cs, minutes), damageShare, visionPerMin: average(rawParticipant?.visionScore ?? 0, minutes), }); return { matchId: match._id.toString(), title: match.title, scheduledAt: match.scheduledAt, gameNumber: game.gameNumber, riotMatchId: game.riotMatchId, gameCreation: game.gameCreation, gameDuration: game.gameDuration, participantId: rawParticipant?.participantId, checkpoints, userId: participant.userId.toString(), summonerName: snapshot?.gameName ?? rawParticipant?.riotIdGameName ?? rawParticipant?.summonerName ?? 'Unknown', tagLine: snapshot?.tagLine ?? rawParticipant?.riotIdTagLine ?? '', profileIconId: snapshot?.profileIconId ?? 0, teamIndex: participant.teamIndex, side: participant.side, championId: participant.championId, championLevel: rawParticipant?.champLevel ?? 0, teamPosition: rawParticipant?.teamPosition || rawParticipant?.individualPosition || '', kills: participant.kills, deaths: participant.deaths, assists: participant.assists, win: participant.win, cs, csPerMin: average(cs, minutes), gold: rawParticipant?.goldEarned ?? 0, gpm: average(rawParticipant?.goldEarned ?? 0, minutes), damageDealtToChampions: damage, damageTaken: rawParticipant?.totalDamageTaken ?? 0, damageShare, killParticipation, visionScore: rawParticipant?.visionScore ?? 0, controlWardsBought: numberField( rawParticipant, 'visionWardsBoughtInGame', ), wardsPlaced: rawParticipant?.wardsPlaced ?? 0, wardsKilled: rawParticipant?.wardsKilled ?? 0, firstBloodKill: booleanField(rawParticipant, 'firstBloodKill'), firstBloodAssist: booleanField(rawParticipant, 'firstBloodAssist'), items: [ rawParticipant?.item0 ?? 0, rawParticipant?.item1 ?? 0, rawParticipant?.item2 ?? 0, rawParticipant?.item3 ?? 0, rawParticipant?.item4 ?? 0, rawParticipant?.item5 ?? 0, ], trinket: rawParticipant?.item6 ?? 0, summonerSpells: [ rawParticipant?.summoner1Id ?? 0, rawParticipant?.summoner2Id ?? 0, ], perks: rawParticipant ? this.resolvePerks(rawParticipant) : {}, itemBuild: buildEvents?.items ?? [], skillBuild: buildEvents?.skills ?? [], rating, }; } private resolvePerks(participant: RiotMatchParticipantDto) { const primary = participant.perks.styles.find( (style) => style.description === 'primaryStyle', ); const sub = participant.perks.styles.find( (style) => style.description === 'subStyle', ); return { primaryStyle: primary?.style, subStyle: sub?.style, keystone: primary?.selections[0]?.perk, selectedPerkIds: participant.perks.styles.flatMap((style) => style.selections.map((selection) => selection.perk), ), styles: participant.perks.styles.map((style) => ({ styleId: style.style, perkIds: style.selections.map((selection) => selection.perk), })), statPerks: { offense: participant.perks.statPerks.offense, flex: participant.perks.statPerks.flex, defense: participant.perks.statPerks.defense, }, }; } private toBuildEventsByParticipantId( timeline?: RiotMatchTimelineDto, ): Map { const buildEventsByParticipantId = new Map(); if (!timeline?.info.frames.length) return buildEventsByParticipantId; const getEvents = (participantId: number): ParticipantBuildEvents => { const current = buildEventsByParticipantId.get(participantId); if (current) return current; const created: ParticipantBuildEvents = { items: [], skills: [] }; buildEventsByParticipantId.set(participantId, created); return created; }; for (const frame of timeline.info.frames) { for (const event of frame.events ?? []) { const participantId = event.participantId; if (!participantId) continue; const timestamp = Math.max(0, Math.round(event.timestamp / 1000)); if (event.type === 'SKILL_LEVEL_UP' && isSkillSlot(event.skillSlot)) { const skills = getEvents(participantId).skills; skills.push({ timestamp, skillSlot: event.skillSlot, level: skills.length + 1, levelUpType: event.levelUpType, }); continue; } const itemType = toItemBuildType(event.type); if (!itemType) continue; const itemId = event.itemId ?? event.afterId ?? event.beforeId ?? 0; if (itemId <= 0) continue; getEvents(participantId).items.push({ timestamp, itemId, type: itemType, beforeId: event.beforeId, afterId: event.afterId, }); } } for (const events of buildEventsByParticipantId.values()) { events.items.sort((left, right) => left.timestamp - right.timestamp); events.skills.sort((left, right) => left.timestamp - right.timestamp); } return buildEventsByParticipantId; } private toCheckpointsByParticipantId( timeline: RiotMatchTimelineDto | undefined, gameDurationSeconds: number, ): Map { const checkpointsByParticipantId = new Map< number, MatchStatsParticipantCheckpoints >(); if ( !timeline?.info.frames.length || !Number.isFinite(timeline.info.frameInterval) || timeline.info.frameInterval <= 0 ) { return checkpointsByParticipantId; } const participantIds = new Set(); const championKillEvents = timeline.info.frames.flatMap((frame) => (frame.events ?? []).filter((event) => event.type === 'CHAMPION_KILL'), ); for (const frame of timeline.info.frames) { for (const participantFrame of Object.values(frame.participantFrames)) { participantIds.add(participantFrame.participantId); } } const targets = [ ['at10', 600_000], ['at15', 900_000], ] as const; for (const participantId of participantIds) { const checkpoints: MatchStatsParticipantCheckpoints = {}; for (const [key, targetTimestamp] of targets) { if (gameDurationSeconds * 1_000 < targetTimestamp) continue; const selectedFrame = timeline.info.frames.reduce< RiotMatchTimelineDto['info']['frames'][number] | undefined >((latest, frame) => { if ( frame.timestamp > targetTimestamp || !Object.values(frame.participantFrames).some( (participantFrame) => participantFrame.participantId === participantId, ) ) { return latest; } return !latest || frame.timestamp > latest.timestamp ? frame : latest; }, undefined); if ( !selectedFrame || targetTimestamp - selectedFrame.timestamp >= timeline.info.frameInterval ) { continue; } const participantFrame = Object.values( selectedFrame.participantFrames, ).find((frame) => frame.participantId === participantId); if ( !participantFrame || typeof participantFrame.minionsKilled !== 'number' || !Number.isFinite(participantFrame.minionsKilled) || typeof participantFrame.jungleMinionsKilled !== 'number' || !Number.isFinite(participantFrame.jungleMinionsKilled) ) { continue; } const checkpoint: MatchStatsCheckpoint = { timestamp: Math.max(0, Math.round(selectedFrame.timestamp / 1_000)), gold: participantFrame.totalGold, cs: participantFrame.minionsKilled + participantFrame.jungleMinionsKilled, xp: participantFrame.xp, kills: 0, deaths: 0, assists: 0, }; for (const event of championKillEvents) { if (event.timestamp > selectedFrame.timestamp) continue; if (event.killerId === participantId && event.killerId > 0) { checkpoint.kills += 1; } if (event.victimId === participantId) checkpoint.deaths += 1; if (event.assistingParticipantIds?.includes(participantId)) { checkpoint.assists += 1; } } checkpoints[key] = checkpoint; } if (checkpoints.at10 || checkpoints.at15) { checkpointsByParticipantId.set(participantId, checkpoints); } } return checkpointsByParticipantId; } private toTimeline( raw: RiotMatchDto, rawTeamIdBySide: Map, timeline?: RiotMatchTimelineDto, ): MatchStatsTimelinePoint[] { if (!timeline?.info.frames.length) return []; const sideByParticipantId = this.toSideByParticipantId( raw, rawTeamIdBySide, ); const points = timeline.info.frames.map((frame) => { const point: MatchStatsTimelinePoint = { timestamp: Math.max(0, Math.round(frame.timestamp / 1000)), blue: { gold: 0, xp: 0 }, red: { gold: 0, xp: 0 }, goldDiff: 0, xpDiff: 0, }; for (const participantFrame of Object.values(frame.participantFrames)) { const side = sideByParticipantId.get(participantFrame.participantId); if (!side) continue; point[side].gold += participantFrame.totalGold; point[side].xp += participantFrame.xp; } point.goldDiff = point.blue.gold - point.red.gold; point.xpDiff = point.blue.xp - point.red.xp; return point; }); return points.filter( (point, index) => index === 0 || point.timestamp !== points[index - 1].timestamp, ); } private toSideByParticipantId( raw: RiotMatchDto, rawTeamIdBySide: Map, ): Map { const blueTeamId = rawTeamIdBySide.get('blue') ?? 100; const redTeamId = rawTeamIdBySide.get('red') ?? 200; const sideByParticipantId = new Map(); for (const participant of raw.info.participants) { if (participant.teamId === blueTeamId) { sideByParticipantId.set(participant.participantId, 'blue'); } if (participant.teamId === redTeamId) { sideByParticipantId.set(participant.participantId, 'red'); } } return sideByParticipantId; } private toTimelineEvents( timeline: RiotMatchTimelineDto | undefined, rawTeamIdBySide: Map, sideByParticipantId: Map, ): TimelineProjection { if (!timeline?.info.frames.length) { return { objectiveEvents: [], timelineEvents: [] }; } const sideByTeamId = new Map(); for (const [side, teamId] of rawTeamIdBySide.entries()) { sideByTeamId.set(teamId, side); } const projected: Array<{ sourceSequence: number; event: MatchStatsTimelineEvent; }> = []; let sourceSequence = 0; for (const frame of timeline.info.frames) { for (const event of frame.events ?? []) { const currentSequence = sourceSequence; sourceSequence += 1; const timestamp = Math.max(0, Math.round(event.timestamp / 1000)); if (event.type === 'ELITE_MONSTER_KILL') { const side = (typeof event.killerTeamId === 'number' ? sideByTeamId.get(event.killerTeamId) : undefined) ?? (typeof event.killerId === 'number' ? sideByParticipantId.get(event.killerId) : undefined); if (!side) continue; const objectiveEvent = toObjectiveTimelineEvent({ timestamp, side, monsterType: event.monsterType, monsterSubType: event.monsterSubType, }); if (objectiveEvent) { projected.push({ sourceSequence: currentSequence, event: objectiveEvent, }); } continue; } if (event.type === 'CHAMPION_KILL') { const side = typeof event.killerId === 'number' && event.killerId > 0 ? sideByParticipantId.get(event.killerId) : undefined; projected.push({ sourceSequence: currentSequence, event: { timestamp, type: 'championKill', ...(side ? { side } : {}), ...(typeof event.killerId === 'number' && event.killerId > 0 ? { killerParticipantId: event.killerId } : {}), ...(typeof event.victimId === 'number' && event.victimId > 0 ? { victimParticipantId: event.victimId } : {}), ...(event.assistingParticipantIds ? { assistingParticipantIds: event.assistingParticipantIds } : {}), }, }); continue; } if (event.type !== 'BUILDING_KILL') continue; const destroyedSide = typeof event.teamId === 'number' ? sideByTeamId.get(event.teamId) : undefined; const side = (typeof event.killerId === 'number' && event.killerId > 0 ? sideByParticipantId.get(event.killerId) : undefined) ?? (destroyedSide ? oppositeSide(destroyedSide) : undefined); const type = event.buildingType === 'TOWER_BUILDING' ? 'tower' : event.buildingType === 'INHIBITOR_BUILDING' ? 'inhibitor' : undefined; if (!side || !type) continue; projected.push({ sourceSequence: currentSequence, event: { timestamp, side, type, ...(typeof event.killerId === 'number' && event.killerId > 0 ? { killerParticipantId: event.killerId } : {}), ...(type === 'tower' && event.towerType ? { towerType: event.towerType } : {}), }, }); } } const timelineEvents = projected .sort( (left, right) => left.event.timestamp - right.event.timestamp || left.sourceSequence - right.sourceSequence, ) .map(({ event }) => event); return { timelineEvents, objectiveEvents: timelineEvents.filter(isObjectiveTimelineEvent), }; } private toTimelineObjectives( objectiveEvents: MatchStatsObjectiveEvent[], ): Map { const objectives = new Map([ ['blue', emptyObjectives()], ['red', emptyObjectives()], ]); for (const event of objectiveEvents) { const current = objectives.get(event.side) ?? emptyObjectives(); switch (event.type) { case 'baron': current.baron += 1; break; case 'riftHerald': current.riftHerald += 1; break; case 'voidGrub': current.voidGrub += 1; break; case 'dragon': current.dragon += 1; break; case 'elderDragon': current.elderDragon += 1; break; default: break; } objectives.set(event.side, current); } return objectives; } private toObjectiveSummary( rawTeam: RiotMatchDto['info']['teams'][number] | undefined, timelineObjectives: MatchStatsObjectiveSummary | undefined, ): MatchStatsObjectiveSummary { const rawObjectives = rawTeam?.objectives; const timelineDragon = timelineObjectives?.dragon ?? 0; const timelineElder = timelineObjectives?.elderDragon ?? 0; const hasProjectedDragon = timelineDragon + timelineElder > 0; return { tower: rawObjectives?.tower?.kills ?? 0, dragon: hasProjectedDragon ? timelineDragon : (rawObjectives?.dragon?.kills ?? 0), inhibitor: rawObjectives?.inhibitor?.kills ?? 0, baron: (timelineObjectives?.baron ?? 0) > 0 ? (timelineObjectives?.baron ?? 0) : (rawObjectives?.baron?.kills ?? 0), riftHerald: (timelineObjectives?.riftHerald ?? 0) > 0 ? (timelineObjectives?.riftHerald ?? 0) : (rawObjectives?.riftHerald?.kills ?? 0), voidGrub: (timelineObjectives?.voidGrub ?? 0) > 0 ? (timelineObjectives?.voidGrub ?? 0) : (rawObjectives?.horde?.kills ?? 0), elderDragon: hasProjectedDragon ? timelineElder : 0, }; } private resolveRating(params: { kills: number; deaths: number; assists: number; killParticipation: number; csPerMin: number; damageShare: number; visionPerMin: number; }): number { const kdaScore = kda(params.kills, params.deaths, params.assists); const score = Math.min(kdaScore / 6, 1) * 4 + Math.min(params.killParticipation / 100, 1) * 2 + Math.min(params.csPerMin / 9, 1) * 2 + Math.min(params.damageShare / 35, 1) + Math.min(params.visionPerMin / 2, 1); return round(score); } } function kda(kills: number, deaths: number, assists: number): number { return deaths === 0 ? kills + assists : round((kills + assists) / deaths); } function percent(value: number, total: number): number { return total > 0 ? Math.round((value / total) * 100) : 0; } function average(value: number, total: number): number { return total > 0 ? round(value / total) : 0; } function isSkillSlot(value: number | undefined): value is 1 | 2 | 3 | 4 { return value === 1 || value === 2 || value === 3 || value === 4; } function toItemBuildType( value: string, ): MatchStatsItemBuildEvent['type'] | null { switch (value) { case 'ITEM_PURCHASED': return 'purchased'; case 'ITEM_SOLD': return 'sold'; case 'ITEM_DESTROYED': return 'destroyed'; case 'ITEM_UNDO': return 'undo'; default: return null; } } function toObjectiveTimelineEvent(params: { timestamp: number; side: TeamSide; monsterType?: string; monsterSubType?: string; }): MatchStatsObjectiveEvent | null { switch (params.monsterType) { case 'BARON_NASHOR': return { timestamp: params.timestamp, side: params.side, type: 'baron' }; case 'RIFTHERALD': return { timestamp: params.timestamp, side: params.side, type: 'riftHerald', }; case 'HORDE': return { timestamp: params.timestamp, side: params.side, type: 'voidGrub', }; case 'DRAGON': return { timestamp: params.timestamp, side: params.side, type: params.monsterSubType === 'ELDER_DRAGON' ? 'elderDragon' : 'dragon', monsterSubType: params.monsterSubType, }; default: return null; } } function isObjectiveTimelineEvent( event: MatchStatsTimelineEvent, ): event is MatchStatsObjectiveEvent { return ( event.type === 'dragon' || event.type === 'elderDragon' || event.type === 'baron' || event.type === 'riftHerald' || event.type === 'voidGrub' ); } function oppositeSide(side: TeamSide): TeamSide { return side === 'blue' ? 'red' : 'blue'; } function isUsableTimeline( timeline: RiotMatchTimelineDto | undefined, gameDurationSeconds: number, ): timeline is RiotMatchTimelineDto { if ( !timeline || !Number.isFinite(timeline.info.frameInterval) || timeline.info.frameInterval <= 0 || !Array.isArray(timeline.info.frames) || timeline.info.frames.length === 0 ) { return false; } const finalTimestamp = Math.max( ...timeline.info.frames.map((frame) => frame.timestamp), ); return ( Number.isFinite(finalTimestamp) && Math.abs(gameDurationSeconds * 1_000 - finalTimestamp) < timeline.info.frameInterval ); } function round(value: number): number { return Math.round(value * 10) / 10; } function numberField( participant: RiotMatchParticipantDto | undefined, key: string, ): number { const value = participant?.[key]; return typeof value === 'number' && Number.isFinite(value) ? value : 0; } function booleanField( participant: RiotMatchParticipantDto | undefined, key: string, ): boolean { return participant?.[key] === true; } function emptyObjectives(): MatchStatsObjectiveSummary { return { tower: 0, dragon: 0, inhibitor: 0, baron: 0, riftHerald: 0, voidGrub: 0, elderDragon: 0, }; }