Files
persona-lenz/apps/api/src/modules/analysis/timeline-derived.service.ts
T
2026-07-02 23:50:10 -07:00

958 lines
25 KiB
TypeScript

import {
ADVANTAGE_EVENT_WEIGHTS,
SUMMONERS_RIFT_MAP,
type AdvantageEventType,
type SummonersRiftMapZone,
} from '@persona-lenz/shared';
import { Injectable } from '@nestjs/common';
interface TimelinePosition {
x: number;
y: number;
}
interface TimelineChampionKillEvent {
timestamp: number;
killerId?: number;
victimId?: number;
shutdownBounty?: number;
assistingParticipantIds: number[];
position?: TimelinePosition;
victimDamageReceived: Array<{
participantId: number;
damage: number;
}>;
}
interface TimelineEliteMonsterKillEvent {
timestamp: number;
killerParticipantId?: number;
killerTeamId?: number;
monsterType?: string;
monsterSubType?: string;
position?: TimelinePosition;
}
interface TimelineFrameSnapshot {
timestamp: number;
participantPositions: Map<number, TimelinePosition>;
}
interface TimelineRoamParticipant {
participantId: number;
teamId: 100 | 200;
assignedLaneZone: SummonersRiftMapZone;
baseZone: SummonersRiftMapZone;
}
export interface TimelineFightCluster {
startTimeMs: number;
endTimeMs: number;
killCount: number;
participantIds: number[];
openerParticipantIds: number[];
cleanupParticipantIds: number[];
isTeamfight: boolean;
}
export interface TimelineObjectiveWindow {
objectiveTimeMs: number;
startTimeMs: number;
endTimeMs: number;
killerParticipantId?: number;
killerTeamId?: number;
monsterType?: string;
monsterSubType?: string;
position?: TimelinePosition;
}
export interface TimelineAdvantageEvent {
timestampMs: number;
teamId: number;
type: AdvantageEventType;
score: number;
participantIds: number[];
}
export interface TimelineDeathEvent {
t: number;
victimParticipantId: number;
x: number;
y: number;
zone: SummonersRiftMapZone;
shutdownBountyGiven: number;
nearestAllyDistanceApprox: number | null;
}
export interface TimelineRoamFrame {
t: number;
participantId: number;
teamId: number;
x: number;
y: number;
zone: SummonersRiftMapZone;
assignedLaneZone: SummonersRiftMapZone;
}
export interface TimelineDerivedData {
fightClusters: TimelineFightCluster[];
advantageEvents: TimelineAdvantageEvent[];
deathEvents: TimelineDeathEvent[];
objectiveWindows: TimelineObjectiveWindow[];
roamFrames: TimelineRoamFrame[];
}
const FIGHT_CLUSTER_MAX_GAP_MS = 15_000;
const FIGHT_CLUSTER_MAX_DISTANCE = 3_000;
const CLEANUP_WINDOW_MS = 5_000;
const OBJECTIVE_WINDOW_BEFORE_MS = 120_000;
const OBJECTIVE_WINDOW_AFTER_MS = 30_000;
const ROAM_FRAME_START_MS = 8 * 60_000;
const ROAM_FRAME_END_MS = 14 * 60_000;
const OBJECTIVE_MONSTER_TYPES = new Set([
'DRAGON',
'RIFTHERALD',
'BARON_NASHOR',
]);
function asRecord(value: unknown): Record<string, unknown> {
if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
return value as Record<string, unknown>;
}
return {};
}
function asArray(value: unknown): unknown[] {
return Array.isArray(value) ? value : [];
}
function asNumber(value: unknown): number | undefined {
return typeof value === 'number' && Number.isFinite(value)
? value
: undefined;
}
function asString(value: unknown): string | undefined {
return typeof value === 'string' ? value : undefined;
}
function asParticipantId(value: unknown): number | undefined {
const participantId = asNumber(value);
return participantId !== undefined && participantId > 0
? participantId
: undefined;
}
function toSortedIds(values: Iterable<number>): number[] {
return [...new Set(values)].sort((left, right) => left - right);
}
function parsePosition(value: unknown): TimelinePosition | undefined {
const position = asRecord(value);
const x = asNumber(position.x);
const y = asNumber(position.y);
if (x === undefined || y === undefined) {
return undefined;
}
return { x, y };
}
function distance(
left: TimelinePosition | undefined,
right: TimelinePosition | undefined,
): number {
if (!left || !right) {
return Number.POSITIVE_INFINITY;
}
return Math.hypot(left.x - right.x, left.y - right.y);
}
function isWithinRadius(
position: TimelinePosition,
center: TimelinePosition,
radius: number,
): boolean {
return distance(position, center) <= radius;
}
function classifySummonersRiftPosition(
position: TimelinePosition | undefined,
): SummonersRiftMapZone {
if (!position) {
return 'unknown';
}
const {
baronPit,
baseRadius,
coordinateMax,
coordinateMin,
dragonPit,
jungleMidline,
laneAxisHalfWidth,
objectivePitRadius,
riverBandHalfWidth,
} = SUMMONERS_RIFT_MAP;
const { x, y } = position;
if (
x < coordinateMin ||
y < coordinateMin ||
x > coordinateMax ||
y > coordinateMax
) {
return 'unknown';
}
if (isWithinRadius(position, dragonPit, objectivePitRadius)) {
return 'dragonPit';
}
if (isWithinRadius(position, baronPit, objectivePitRadius)) {
return 'baronPit';
}
if (x <= baseRadius && y <= baseRadius) {
return 'blueBase';
}
if (x >= coordinateMax - baseRadius && y >= coordinateMax - baseRadius) {
return 'redBase';
}
if (Math.abs(x + y - coordinateMax) <= riverBandHalfWidth) {
return 'river';
}
if (x <= laneAxisHalfWidth || y >= coordinateMax - laneAxisHalfWidth) {
return 'topLane';
}
if (Math.abs(x - y) <= laneAxisHalfWidth) {
return 'middleLane';
}
if (y <= laneAxisHalfWidth || x >= coordinateMax - laneAxisHalfWidth) {
return 'bottomLane';
}
if (x < jungleMidline && y >= jungleMidline) {
return 'northWestJungle';
}
if (x >= jungleMidline && y >= jungleMidline) {
return 'northEastJungle';
}
if (x < jungleMidline && y < jungleMidline) {
return 'southWestJungle';
}
if (x >= jungleMidline && y < jungleMidline) {
return 'southEastJungle';
}
return 'unknown';
}
function isConnectedKill(
left: TimelineChampionKillEvent,
right: TimelineChampionKillEvent,
): boolean {
return (
Math.abs(left.timestamp - right.timestamp) <= FIGHT_CLUSTER_MAX_GAP_MS &&
distance(left.position, right.position) <= FIGHT_CLUSTER_MAX_DISTANCE
);
}
function eventParticipantIds(event: TimelineChampionKillEvent): number[] {
return toSortedIds(
[
event.killerId,
event.victimId,
...event.assistingParticipantIds,
...event.victimDamageReceived.map((damage) => damage.participantId),
].filter((id): id is number => id !== undefined),
);
}
function eventOpenerParticipantIds(event: TimelineChampionKillEvent): number[] {
const damageByParticipantId = new Map<number, number>();
for (const damage of event.victimDamageReceived) {
damageByParticipantId.set(
damage.participantId,
(damageByParticipantId.get(damage.participantId) ?? 0) + damage.damage,
);
}
const highestDamageContributor = [...damageByParticipantId.entries()].reduce<
{ participantId: number; damage: number } | undefined
>((selected, [participantId, damage]) => {
if (!selected || damage > selected.damage) {
return { participantId, damage };
}
return selected;
}, undefined);
return toSortedIds(
[
event.killerId,
...event.assistingParticipantIds,
highestDamageContributor?.participantId,
].filter((id): id is number => id !== undefined),
);
}
function isObjectiveMonsterType(monsterType: string | undefined): boolean {
return monsterType !== undefined && OBJECTIVE_MONSTER_TYPES.has(monsterType);
}
function objectiveAdvantageEventType(
monsterType: string | undefined,
): AdvantageEventType | undefined {
switch (monsterType) {
case 'DRAGON':
return 'dragon';
case 'RIFTHERALD':
return 'riftHerald';
case 'BARON_NASHOR':
return 'baron';
default:
return undefined;
}
}
function teamIdFromParticipantId(
participantId: number | undefined,
): 100 | 200 | undefined {
if (participantId === undefined) {
return undefined;
}
if (participantId >= 1 && participantId <= 5) {
return 100;
}
if (participantId >= 6 && participantId <= 10) {
return 200;
}
return undefined;
}
function toTeamId(value: unknown): 100 | 200 | undefined {
const teamId = asNumber(value);
return teamId === 100 || teamId === 200 ? teamId : undefined;
}
function opposingTeamId(teamId: 100 | 200 | undefined): 100 | 200 | undefined {
if (teamId === 100) {
return 200;
}
if (teamId === 200) {
return 100;
}
return undefined;
}
function assignedLaneZoneForRole(
teamPosition: string | undefined,
): SummonersRiftMapZone | undefined {
switch (teamPosition) {
case 'TOP':
return 'topLane';
case 'MIDDLE':
return 'middleLane';
case 'BOTTOM':
case 'UTILITY':
return 'bottomLane';
default:
return undefined;
}
}
function baseZoneForTeamId(
teamId: 100 | 200 | undefined,
): SummonersRiftMapZone | undefined {
switch (teamId) {
case 100:
return 'blueBase';
case 200:
return 'redBase';
default:
return undefined;
}
}
function parseRoamParticipants(
rawMatch: Record<string, unknown> | undefined,
): TimelineRoamParticipant[] {
const info = asRecord(rawMatch?.info);
return asArray(info.participants)
.map(asRecord)
.flatMap((participant) => {
const participantId = asParticipantId(participant.participantId);
const teamId = toTeamId(participant.teamId);
const assignedLaneZone = assignedLaneZoneForRole(
asString(participant.teamPosition),
);
const baseZone = baseZoneForTeamId(teamId);
if (
participantId === undefined ||
teamId === undefined ||
assignedLaneZone === undefined ||
baseZone === undefined
) {
return [];
}
return [
{
participantId,
teamId,
assignedLaneZone,
baseZone,
},
];
});
}
function scoringParticipantIds(event: TimelineChampionKillEvent): number[] {
return toSortedIds(
[
event.killerId,
...event.assistingParticipantIds,
...event.victimDamageReceived.map((damage) => damage.participantId),
].filter((id): id is number => id !== undefined),
);
}
function parseAssistingParticipantIds(value: unknown): number[] {
return toSortedIds(
asArray(value).flatMap((item) => {
const participantId = asParticipantId(item);
return participantId === undefined ? [] : [participantId];
}),
);
}
function parseVictimDamageReceived(
value: unknown,
): TimelineChampionKillEvent['victimDamageReceived'] {
return asArray(value).flatMap((item) => {
const damageRecord = asRecord(item);
const participantId = asParticipantId(damageRecord.participantId);
if (participantId === undefined) {
return [];
}
const explicitDamage =
asNumber(damageRecord.totalDamageDone) ?? asNumber(damageRecord.damage);
const componentDamage =
(asNumber(damageRecord.magicDamageDone) ?? 0) +
(asNumber(damageRecord.physicalDamageDone) ?? 0) +
(asNumber(damageRecord.trueDamageDone) ?? 0);
return [
{
participantId,
damage: explicitDamage ?? componentDamage,
},
];
});
}
function parseChampionKillEvent(
event: Record<string, unknown>,
): TimelineChampionKillEvent | undefined {
const timestamp = asNumber(event.timestamp);
if (timestamp === undefined) {
return undefined;
}
return {
timestamp,
killerId: asParticipantId(event.killerId),
victimId: asParticipantId(event.victimId),
shutdownBounty: asNumber(event.shutdownBounty),
assistingParticipantIds: parseAssistingParticipantIds(
event.assistingParticipantIds,
),
position: parsePosition(event.position),
victimDamageReceived: parseVictimDamageReceived(event.victimDamageReceived),
};
}
function parseTimelineFrame(
frame: Record<string, unknown>,
): TimelineFrameSnapshot | undefined {
const timestamp = asNumber(frame.timestamp);
if (timestamp === undefined) {
return undefined;
}
const participantFrames = asRecord(frame.participantFrames);
const participantPositions = new Map<number, TimelinePosition>();
for (const [participantIdValue, participantFrameValue] of Object.entries(
participantFrames,
)) {
const participantId = asParticipantId(Number(participantIdValue));
const participantFrame = asRecord(participantFrameValue);
const position = parsePosition(participantFrame.position);
if (participantId !== undefined && position) {
participantPositions.set(participantId, position);
}
}
return {
timestamp,
participantPositions,
};
}
function parseEliteMonsterKillEvent(
event: Record<string, unknown>,
): TimelineEliteMonsterKillEvent | undefined {
const timestamp = asNumber(event.timestamp);
if (timestamp === undefined) {
return undefined;
}
return {
timestamp,
killerParticipantId: asParticipantId(event.killerId),
killerTeamId: asNumber(event.killerTeamId),
monsterType: asString(event.monsterType),
monsterSubType: asString(event.monsterSubType),
position: parsePosition(event.position),
};
}
function structureParticipantIds(event: Record<string, unknown>): number[] {
return toSortedIds(
[
asParticipantId(event.killerId),
...parseAssistingParticipantIds(event.assistingParticipantIds),
].filter((id): id is number => id !== undefined),
);
}
function createStructureAdvantageEvent(
event: Record<string, unknown>,
type: AdvantageEventType,
): TimelineAdvantageEvent | undefined {
const timestamp = asNumber(event.timestamp);
const participantIds = structureParticipantIds(event);
const teamId =
teamIdFromParticipantId(participantIds[0]) ??
opposingTeamId(toTeamId(event.teamId));
if (timestamp === undefined || !teamId) {
return undefined;
}
return {
timestampMs: timestamp,
teamId,
type,
score: ADVANTAGE_EVENT_WEIGHTS[type],
participantIds,
};
}
function createChampionKillAdvantageEvent(
event: TimelineChampionKillEvent,
): TimelineAdvantageEvent | undefined {
const teamId = teamIdFromParticipantId(event.killerId);
if (event.killerId === undefined || !teamId) {
return undefined;
}
return {
timestampMs: event.timestamp,
teamId,
type: 'championKill',
score: ADVANTAGE_EVENT_WEIGHTS.championKill,
participantIds: scoringParticipantIds(event),
};
}
function createEliteMonsterAdvantageEvent(
event: TimelineEliteMonsterKillEvent,
): TimelineAdvantageEvent | undefined {
const type = objectiveAdvantageEventType(event.monsterType);
if (!type) {
return undefined;
}
const teamId =
toTeamId(event.killerTeamId) ??
teamIdFromParticipantId(event.killerParticipantId);
if (!teamId) {
return undefined;
}
return {
timestampMs: event.timestamp,
teamId,
type,
score: ADVANTAGE_EVENT_WEIGHTS[type],
participantIds:
event.killerParticipantId === undefined
? []
: [event.killerParticipantId],
};
}
function createBuildingAdvantageEvent(
event: Record<string, unknown>,
): TimelineAdvantageEvent | undefined {
const buildingType = asString(event.buildingType);
const towerType = asString(event.towerType);
if (buildingType !== 'TOWER_BUILDING' && towerType === undefined) {
return undefined;
}
return createStructureAdvantageEvent(event, 'tower');
}
function extractTimelineEvents(timeline: Record<string, unknown>) {
const info = asRecord(timeline.info);
const frames = asArray(info.frames).map(asRecord);
const championKills: TimelineChampionKillEvent[] = [];
const eliteMonsterKills: TimelineEliteMonsterKillEvent[] = [];
const advantageEvents: TimelineAdvantageEvent[] = [];
const frameSnapshots: TimelineFrameSnapshot[] = [];
for (const frame of frames) {
const frameSnapshot = parseTimelineFrame(frame);
if (frameSnapshot) {
frameSnapshots.push(frameSnapshot);
}
for (const rawEvent of asArray(frame.events)) {
const event = asRecord(rawEvent);
switch (asString(event.type)) {
case 'CHAMPION_KILL': {
const championKill = parseChampionKillEvent(event);
if (championKill) {
championKills.push(championKill);
const advantageEvent =
createChampionKillAdvantageEvent(championKill);
if (advantageEvent) {
advantageEvents.push(advantageEvent);
}
}
break;
}
case 'ELITE_MONSTER_KILL': {
const eliteMonsterKill = parseEliteMonsterKillEvent(event);
if (eliteMonsterKill) {
eliteMonsterKills.push(eliteMonsterKill);
const advantageEvent =
createEliteMonsterAdvantageEvent(eliteMonsterKill);
if (advantageEvent) {
advantageEvents.push(advantageEvent);
}
}
break;
}
case 'TURRET_PLATE_DESTROYED': {
const advantageEvent = createStructureAdvantageEvent(
event,
'turretPlate',
);
if (advantageEvent) {
advantageEvents.push(advantageEvent);
}
break;
}
case 'BUILDING_KILL': {
const advantageEvent = createBuildingAdvantageEvent(event);
if (advantageEvent) {
advantageEvents.push(advantageEvent);
}
break;
}
}
}
}
return {
championKills: championKills.sort(
(left, right) => left.timestamp - right.timestamp,
),
eliteMonsterKills: eliteMonsterKills.sort(
(left, right) => left.timestamp - right.timestamp,
),
advantageEvents: advantageEvents.sort(
(left, right) => left.timestampMs - right.timestampMs,
),
frameSnapshots: frameSnapshots.sort(
(left, right) => left.timestamp - right.timestamp,
),
};
}
function findRoot(parents: number[], index: number): number {
let root = index;
while (parents[root] !== root) {
root = parents[root];
}
while (parents[index] !== index) {
const parent = parents[index];
parents[index] = root;
index = parent;
}
return root;
}
function union(parents: number[], left: number, right: number): void {
const leftRoot = findRoot(parents, left);
const rightRoot = findRoot(parents, right);
if (leftRoot !== rightRoot) {
parents[rightRoot] = leftRoot;
}
}
function buildFightClusters(
kills: TimelineChampionKillEvent[],
): TimelineFightCluster[] {
const parents = kills.map((_, index) => index);
for (let leftIndex = 0; leftIndex < kills.length; leftIndex += 1) {
for (
let rightIndex = leftIndex + 1;
rightIndex < kills.length;
rightIndex += 1
) {
if (isConnectedKill(kills[leftIndex], kills[rightIndex])) {
union(parents, leftIndex, rightIndex);
}
}
}
const clusterGroups = new Map<number, TimelineChampionKillEvent[]>();
for (const [index, kill] of kills.entries()) {
const root = findRoot(parents, index);
clusterGroups.set(root, [...(clusterGroups.get(root) ?? []), kill]);
}
return [...clusterGroups.values()]
.map((clusterKills) => {
const sortedKills = [...clusterKills].sort(
(left, right) => left.timestamp - right.timestamp,
);
const firstKill = sortedKills[0];
const lastKill = sortedKills[sortedKills.length - 1];
const cleanupStartTimeMs = lastKill.timestamp - CLEANUP_WINDOW_MS;
const cleanupEndTimeMs = lastKill.timestamp + CLEANUP_WINDOW_MS;
const cleanupParticipantIds = sortedKills
.filter(
(kill) =>
kill.timestamp >= cleanupStartTimeMs &&
kill.timestamp <= cleanupEndTimeMs,
)
.flatMap(eventParticipantIds);
return {
startTimeMs: firstKill.timestamp,
endTimeMs: lastKill.timestamp,
killCount: sortedKills.length,
participantIds: toSortedIds(sortedKills.flatMap(eventParticipantIds)),
openerParticipantIds: eventOpenerParticipantIds(firstKill),
cleanupParticipantIds: toSortedIds(cleanupParticipantIds),
isTeamfight: sortedKills.length >= 3,
};
})
.sort((left, right) => left.startTimeMs - right.startTimeMs);
}
function buildObjectiveWindows(
eliteMonsterKills: TimelineEliteMonsterKillEvent[],
): TimelineObjectiveWindow[] {
return eliteMonsterKills
.filter((event) => isObjectiveMonsterType(event.monsterType))
.map((event) => ({
objectiveTimeMs: event.timestamp,
startTimeMs: event.timestamp - OBJECTIVE_WINDOW_BEFORE_MS,
endTimeMs: event.timestamp + OBJECTIVE_WINDOW_AFTER_MS,
...(event.killerParticipantId !== undefined
? { killerParticipantId: event.killerParticipantId }
: {}),
...(event.killerTeamId !== undefined
? { killerTeamId: event.killerTeamId }
: {}),
...(event.monsterType ? { monsterType: event.monsterType } : {}),
...(event.monsterSubType ? { monsterSubType: event.monsterSubType } : {}),
...(event.position ? { position: event.position } : {}),
}));
}
function interpolatePosition(
frameSnapshots: TimelineFrameSnapshot[],
participantId: number,
timestampMs: number,
): TimelinePosition | undefined {
let previous: { timestamp: number; position: TimelinePosition } | undefined;
let next: { timestamp: number; position: TimelinePosition } | undefined;
for (const frame of frameSnapshots) {
const position = frame.participantPositions.get(participantId);
if (!position) {
continue;
}
if (frame.timestamp <= timestampMs) {
previous = { timestamp: frame.timestamp, position };
}
if (frame.timestamp >= timestampMs) {
next = { timestamp: frame.timestamp, position };
break;
}
}
if (previous && next) {
if (previous.timestamp === next.timestamp) {
return previous.position;
}
const ratio =
(timestampMs - previous.timestamp) /
(next.timestamp - previous.timestamp);
return {
x: previous.position.x + (next.position.x - previous.position.x) * ratio,
y: previous.position.y + (next.position.y - previous.position.y) * ratio,
};
}
return previous?.position ?? next?.position;
}
function nearestAllyDistanceApprox(
frameSnapshots: TimelineFrameSnapshot[],
victimParticipantId: number,
deathPosition: TimelinePosition,
timestampMs: number,
): number | null {
const victimTeamId = teamIdFromParticipantId(victimParticipantId);
if (!victimTeamId) {
return null;
}
let nearestDistance = Number.POSITIVE_INFINITY;
for (let participantId = 1; participantId <= 10; participantId += 1) {
if (
participantId === victimParticipantId ||
teamIdFromParticipantId(participantId) !== victimTeamId
) {
continue;
}
const allyPosition = interpolatePosition(
frameSnapshots,
participantId,
timestampMs,
);
if (!allyPosition) {
continue;
}
nearestDistance = Math.min(
nearestDistance,
distance(deathPosition, allyPosition),
);
}
return Number.isFinite(nearestDistance) ? Math.round(nearestDistance) : null;
}
function buildDeathEvents(
championKills: TimelineChampionKillEvent[],
frameSnapshots: TimelineFrameSnapshot[],
): TimelineDeathEvent[] {
return championKills.flatMap((event) => {
if (event.victimId === undefined) {
return [];
}
const position =
event.position ??
interpolatePosition(frameSnapshots, event.victimId, event.timestamp);
if (!position) {
return [];
}
return [
{
t: event.timestamp,
victimParticipantId: event.victimId,
x: position.x,
y: position.y,
zone: classifySummonersRiftPosition(position),
shutdownBountyGiven: event.shutdownBounty ?? 0,
nearestAllyDistanceApprox: nearestAllyDistanceApprox(
frameSnapshots,
event.victimId,
position,
event.timestamp,
),
},
];
});
}
function buildRoamFrames(
frameSnapshots: TimelineFrameSnapshot[],
rawMatch: Record<string, unknown> | undefined,
): TimelineRoamFrame[] {
const roamParticipants = parseRoamParticipants(rawMatch);
if (roamParticipants.length === 0) {
return [];
}
return frameSnapshots.flatMap((frame) => {
if (
frame.timestamp < ROAM_FRAME_START_MS ||
frame.timestamp > ROAM_FRAME_END_MS
) {
return [];
}
return roamParticipants.flatMap((participant) => {
const position = frame.participantPositions.get(
participant.participantId,
);
if (!position) {
return [];
}
const zone = classifySummonersRiftPosition(position);
if (
zone === 'unknown' ||
zone === participant.assignedLaneZone ||
zone === participant.baseZone
) {
return [];
}
return [
{
t: frame.timestamp,
participantId: participant.participantId,
teamId: participant.teamId,
x: position.x,
y: position.y,
zone,
assignedLaneZone: participant.assignedLaneZone,
},
];
});
});
}
@Injectable()
export class TimelineDerivedService {
public buildDerivedData(
timeline: Record<string, unknown>,
rawMatch?: Record<string, unknown>,
): TimelineDerivedData {
const {
advantageEvents,
championKills,
eliteMonsterKills,
frameSnapshots,
} = extractTimelineEvents(timeline);
return {
fightClusters: buildFightClusters(championKills),
advantageEvents,
deathEvents: buildDeathEvents(championKills, frameSnapshots),
objectiveWindows: buildObjectiveWindows(eliteMonsterKills),
roamFrames: buildRoamFrames(frameSnapshots, rawMatch),
};
}
}