Refactor/parser

apps/parser/src/clutches.ts

@@ -0,0 +1,17 @@
+import type { DemoFile, NewClutch } from "./types.js";
+
+export const createClutches = (data: DemoFile, matchId: string) => {
+	const clutches: NewClutch[] = [];
+	for (const clutch of data.clutches) {
+		clutches.push({
+			matchId,
+			clutcherKillCount: clutch.clutcherKillCount,
+			clutcherSteamId: clutch.clutcherSteamId,
+			hasWon: clutch.hasWon,
+			opponentCount: clutch.opponentCount,
+			roundNumber: clutch.roundNumber,
+			clutcherSurvived: clutch.clutcherSurvived,
+		});
+	}
+	return clutches;
+};

apps/parser/src/duels.ts

@@ -0,0 +1,91 @@
+import type { DemoFile, NewDuel } from "./types.js";
+
+type DuelsMap = Map<string, Map<string, NewDuel>>;
+
+const getOrCreateDuelMap = (duelsMap: DuelsMap, playerId: string) => {
+	let duels = duelsMap.get(playerId);
+	if (!duels) {
+		duels = new Map<string, NewDuel>();
+		duelsMap.set(playerId, duels);
+	}
+	return duels;
+};
+
+const getOrCreateDuel = (
+	duels: Map<string, NewDuel>,
+	playerA: string,
+	playerB: string,
+	matchId: string,
+): NewDuel => {
+	let duel = duels.get(playerB);
+	if (!duel) {
+		duel = {
+			playerA_steamId: playerA,
+			playerB_steamId: playerB,
+			kills: 0,
+			deaths: 0,
+			matchId,
+		};
+		duels.set(playerB, duel);
+	}
+	return duel;
+};
+
+export const createDuels = (data: DemoFile, matchId: string) => {
+	const duelsMap: DuelsMap = new Map();
+	const playerIds = Object.keys(data.players).map(String);
+
+	for (const playerA of playerIds) {
+		const map = new Map<string, NewDuel>();
+
+		for (const playerB of playerIds) {
+			if (playerA === playerB) continue;
+
+			map.set(playerB, {
+				playerA_steamId: playerA,
+				playerB_steamId: playerB,
+				kills: 0,
+				deaths: 0,
+				matchId,
+			});
+		}
+
+		duelsMap.set(playerA, map);
+	}
+
+	for (const kill of data.kills) {
+		const killerId = kill.killerSteamId;
+		const victimId = kill.victimSteamId;
+
+		if (
+			kill.killerSide !== kill.victimSide &&
+			kill.killerSteamId !== "0" &&
+			kill.victimSteamId !== "0"
+		) {
+			const killerDuels = getOrCreateDuelMap(duelsMap, killerId);
+			const victimDuels = getOrCreateDuelMap(duelsMap, victimId);
+
+			const killerDuel = getOrCreateDuel(
+				killerDuels,
+				killerId,
+				victimId,
+				matchId,
+			);
+
+			const victimDuel = getOrCreateDuel(
+				victimDuels,
+				victimId,
+				killerId,
+				matchId,
+			);
+
+			killerDuel.kills += 1;
+			victimDuel.deaths += 1;
+		}
+	}
+
+	const duels = Array.from(duelsMap.values()).flatMap((duel) =>
+		Array.from(duel.values()),
+	);
+	return duels;
+};

apps/parser/src/match.ts

@@ -0,0 +1,10 @@
+import type { DemoFile, NewMatch } from "./types.js";
+
+export const createMatch = (data: DemoFile) => {
+	const newMatch: NewMatch = {
+		date: data.date,
+		id: data.checksum,
+		map: data.mapName,
+	};
+	return newMatch;
+};

apps/parser/src/players.ts

@@ -0,0 +1,185 @@
+import { WeaponName } from "@akiver/cs-demo-analyzer";
+import type { DemoFile, DemoPlayer, NewPlayer } from "./types.js";
+
+type PlayerStats = {
+	totalFlashes: number;
+	totalSmokes: number;
+	totalMolotovs: number;
+	totalHes: number;
+	flashAssists: number;
+	enemiesFlashed: number;
+	friendsFlashed: number;
+	selfFlashed: number;
+	enemiesBlindTime: number;
+	friendsBlindTime: number;
+	selfBlindTime: number;
+	heDamage: number;
+	heTeamDamage: number;
+};
+
+const getOrCreatePlayerStats = (
+	steamId: string,
+	playerStatsMap: Map<string, PlayerStats>,
+): PlayerStats => {
+	let stats = playerStatsMap.get(steamId);
+	if (!stats) {
+		stats = {
+			totalFlashes: 0,
+			totalHes: 0,
+			totalMolotovs: 0,
+			totalSmokes: 0,
+			enemiesBlindTime: 0,
+			friendsBlindTime: 0,
+			enemiesFlashed: 0,
+			flashAssists: 0,
+			friendsFlashed: 0,
+			selfBlindTime: 0,
+			selfFlashed: 0,
+			heDamage: 0,
+			heTeamDamage: 0,
+		};
+		playerStatsMap.set(steamId, stats);
+	}
+	return stats;
+};
+
+export const calculateAggregatedStats = (data: DemoFile) => {
+	const playerStatsMap = new Map<string, PlayerStats>();
+
+	for (const shot of data.shots) {
+		const playerStats = getOrCreatePlayerStats(
+			shot.playerSteamId,
+			playerStatsMap,
+		);
+		switch (shot.weaponName) {
+			case WeaponName.Smoke:
+				playerStats.totalSmokes += 1;
+				break;
+			case WeaponName.Flashbang:
+				playerStats.totalFlashes += 1;
+				break;
+			case WeaponName.Molotov:
+				playerStats.totalMolotovs += 1;
+				break;
+			case WeaponName.Incendiary:
+				playerStats.totalMolotovs += 1;
+				break;
+			case WeaponName.HEGrenade:
+				playerStats.totalHes += 1;
+				break;
+		}
+	}
+
+	for (const flash of data.playersFlashed) {
+		const playerStats = getOrCreatePlayerStats(
+			flash.flasherSteamId,
+			playerStatsMap,
+		);
+
+		if (flash.flasherSide === flash.flashedSide) {
+			// Se bangou
+			if (flash.flashedSteamId === flash.flasherSteamId) {
+				playerStats.selfFlashed++;
+				playerStats.selfBlindTime += flash.duration;
+			}
+			// Bangou amigo
+			else {
+				playerStats.friendsFlashed++;
+				playerStats.friendsBlindTime += flash.duration;
+			}
+			// Bangou o inimigo
+		} else {
+			playerStats.enemiesFlashed++;
+			playerStats.enemiesBlindTime += flash.duration;
+		}
+	}
+
+	for (const damage of data.damages) {
+		const playerStats = getOrCreatePlayerStats(
+			damage.attackerSteamId,
+			playerStatsMap,
+		);
+		if (damage.weaponName === WeaponName.HEGrenade) {
+			if (damage.attackerSide !== damage.victimSide) {
+				playerStats.heDamage += damage.healthDamage;
+			}
+			// HE no amigo
+			else if (damage.attackerSteamId !== damage.victimSteamId) {
+				playerStats.heTeamDamage += damage.healthDamage;
+			}
+		}
+	}
+
+	for (const kill of data.kills) {
+		if (kill.assisterSteamId) {
+			const playerStats = getOrCreatePlayerStats(
+				kill.assisterSteamId,
+				playerStatsMap,
+			);
+			if (kill.isAssistedFlash) {
+				playerStats.flashAssists++;
+			}
+		}
+	}
+
+	const newPlayerMap = new Map<string, NewPlayer>();
+	Object.entries(data.players).forEach(
+		([steamId, player]: [string, DemoPlayer]) => {
+			const playerStats = getOrCreatePlayerStats(steamId, playerStatsMap);
+			const newPlayerData = {
+				steamId,
+				name: player.name,
+				score: player.score,
+				mvpCount: player.mvpCount,
+				winCount: player.winCount,
+				crosshairShareCode: player.crosshairShareCode,
+				color: player.color,
+				killCount: player.killCount,
+				deathCount: player.deathCount,
+				assistCount: player.assistCount,
+				killDeathRatio: player.killDeathRatio,
+				kast: player.kast,
+				bombDefusedCount: player.bombDefusedCount,
+				bombPlantedCount: player.bombPlantedCount,
+				healthDamage: player.healthDamage,
+				armorDamage: player.armorDamage,
+				utilityDamage: player.utilityDamage,
+				headshotCount: player.headshotCount,
+				headshotPercent: player.headshotPercent,
+				hostageRescuedCount: player.hostageRescuedCount,
+				averageKillPerRound: player.averageKillPerRound,
+				averageDeathPerRound: player.averageDeathPerRound,
+				averageDamagePerRound: player.averageDamagePerRound,
+				utilityDamagePerRound: player.utilityDamagePerRound,
+				firstKillCount: player.firstKillCount,
+				firstDeathCount: player.firstDeathCount,
+				firstTradeDeathCount: player.firstTradeDeathCount,
+				tradeDeathCount: player.tradeDeathCount,
+				tradeKillCount: player.tradeKillCount,
+				firstTradeKillCount: player.firstTradeKillCount,
+				oneKillCount: player.oneKillCount,
+				twoKillCount: player.twoKillCount,
+				threeKillCount: player.threeKillCount,
+				fourKillCount: player.fourKillCount,
+				fiveKillCount: player.fiveKillCount,
+				hltvRating: player.hltvRating,
+				hltvRating2: player.hltvRating2,
+				enemiesBlindTime: playerStats.enemiesBlindTime,
+				enemiesFlashed: playerStats.enemiesFlashed,
+				selfFlashed: playerStats.selfFlashed,
+				selfBlindTime: playerStats.selfBlindTime,
+				friendsFlashed: playerStats.friendsFlashed,
+				friendsBlindTime: playerStats.friendsBlindTime,
+				flashAssists: playerStats.flashAssists,
+				heDamage: playerStats.heDamage,
+				heTeamDamage: playerStats.heTeamDamage,
+				totalFlashes: playerStats.totalFlashes,
+				totalHes: playerStats.totalHes,
+				totalMolotovs: playerStats.totalMolotovs,
+				totalSmokes: playerStats.totalSmokes,
+			};
+			newPlayerMap.set(steamId, newPlayerData);
+		},
+	);
+	return newPlayerMap;
+};