@cs2dak/core 0.2.1 → 2.0.0

package/src/scoreboard.ts

@@ -1,7 +1,7 @@
 import {
   computeRR,
   computePrism,
-  rrWeightsV1,
+  hltv2BaselineWeightsV1,
   prismWeightsV1,
   rrToPercentile,
   type RRResult,
@@ -10,17 +10,19 @@ import {
   type PrismComputeInput
 } from "@rivalhub/rival-rating";
 import type {
-  AccountSignalsV2,
   DemoPackage,
   PlayerIndicatorRow,
   PlayerRoundFact,
   PlayerScoreboardRow,
   RRIndicators
 } from "@cs2dak/contract";
-import type { RRResultV2 } from "@rivalhub/rival-rating";
+import type { RRSignals } from "@rivalhub/rival-rating";
+import type { AccountRatingResult } from "./signals.js";
 import { normalizeDemoPackage } from "./normalize.js";
-import { round, firstKillMap, clutchSplit, isUtilityWeapon, killWeaponName } from "./utils.js";
+import { activeDamages, round, firstKillMap, clutchSplit, killWeaponName } from "./utils.js";
+import { createResolverFromPackage } from "./resolve.js";
 import { fieldAvailability, fieldConfidence } from "./qa.js";
+import { buildPlayerRoundUtilityFacts } from "./utility-facts.js";
 
 export function deriveRRIndicators(input: unknown): RRIndicators[] {
   const pkg = normalizeDemoPackage(input);
@@ -28,22 +30,32 @@ export function deriveRRIndicators(input: unknown): RRIndicators[] {
 }
 
 export function buildPlayerRoundFacts(pkg: DemoPackage): PlayerRoundFact[] {
+  const resolver = createResolverFromPackage(pkg);
   const firstKillByRound = firstKillMap(pkg);
+  const damageRows = activeDamages(pkg);
+  const utilityFacts = new Map(buildPlayerRoundUtilityFacts(pkg).map((fact) => [`${fact.roundNumber}:${fact.steamId64}`, fact]));
 
   return pkg.rounds.flatMap((roundRow) =>
-    pkg.players.map((player) => {
-      const kills = pkg.kills.filter((kill) => kill.roundNumber === roundRow.roundNumber && kill.killerSteamId64 === player.steamId64);
-      const deaths = pkg.kills.filter((kill) => kill.roundNumber === roundRow.roundNumber && kill.victimSteamId64 === player.steamId64);
-      const assists = pkg.kills.filter((kill) => kill.roundNumber === roundRow.roundNumber && kill.assisterSteamId64 === player.steamId64);
-      const flashAssists = pkg.kills.filter((kill) => kill.roundNumber === roundRow.roundNumber && kill.flashAssisterSteamId64 === player.steamId64);
-      const damageRows = pkg.damages.filter((row) => row.roundNumber === roundRow.roundNumber && row.attackerSteamId64 === player.steamId64 && row.victimTeamKey !== player.teamKey);
-      const economy = pkg.playerEconomies.find((row) => row.roundNumber === roundRow.roundNumber && row.steamId64 === player.steamId64);
+    pkg.players.map((player, playerIdx) => {
+      const kills = pkg.kills.filter((kill) => kill.roundNumber === roundRow.roundNumber && kill.killerIndex === playerIdx);
+      const deaths = pkg.kills.filter((kill) => kill.roundNumber === roundRow.roundNumber && kill.victimIndex === playerIdx);
+      const assists = pkg.kills.filter((kill) => kill.roundNumber === roundRow.roundNumber && kill.assisterIndex === playerIdx);
+      // Keep the existing PlayerRoundFact assist/KAST semantics (the
+      // flashAssists field itself is supplied by the shared utility helper).
+      const flashAssistRows = pkg.kills.filter((kill) => kill.roundNumber === roundRow.roundNumber && kill.flashAssisterIndex === playerIdx);
+      const utility = utilityFacts.get(`${roundRow.roundNumber}:${player.steamId64}`)!;
+      const playerDamageRows = damageRows.filter((row) =>
+        row.roundNumber === roundRow.roundNumber &&
+        row.attackerIndex === playerIdx &&
+        resolver.byIndexOrNull(row.victimIndex)?.teamKey !== player.teamKey
+      );
+      const economy = pkg.playerEconomies.find((row) => row.roundNumber === roundRow.roundNumber && row.playerIndex === playerIdx);
       const side = player.teamKey === "teamA" ? roundRow.teamASide : roundRow.teamBSide;
       const firstKill = firstKillByRound.get(roundRow.roundNumber);
       const kastTags = new Set<PlayerRoundFact["kastTags"][number]>();
 
       if (kills.length > 0) kastTags.add("kill");
-      if (assists.length > 0 || flashAssists.length > 0) kastTags.add("assist");
+      if (assists.length > 0 || flashAssistRows.length > 0) kastTags.add("assist");
       if (deaths.length === 0) kastTags.add("survive");
       if (deaths.some((death) => death.tradeDeath)) kastTags.add("trade");
 
@@ -56,13 +68,13 @@ export function buildPlayerRoundFacts(pkg: DemoPackage): PlayerRoundFact[] {
         survived: deaths.length === 0,
         kills: kills.length,
         deaths: deaths.length,
-        assists: assists.length + flashAssists.length,
-        damage: damageRows.reduce((sum, row) => sum + row.healthDamage, 0),
-        utilityDamage: damageRows.filter((row) => isUtilityWeapon(row.weapon)).reduce((sum, row) => sum + row.healthDamage, 0),
-        flashAssists: flashAssists.length + kills.filter((kill) => kill.flashAssist).length,
+        assists: assists.length + flashAssistRows.length,
+        damage: playerDamageRows.reduce((sum, row) => sum + row.healthDamage, 0),
+        utilityDamage: utility.utilityDamage,
+        flashAssists: utility.flashAssists,
         tradeKills: kills.filter((kill) => kill.tradeKill).length,
         tradedDeaths: deaths.filter((death) => death.tradeDeath).length,
-        openingDuel: firstKill?.killerSteamId64 === player.steamId64 ? "won" : firstKill?.victimSteamId64 === player.steamId64 ? "lost" : "none",
+        openingDuel: firstKill?.killerIndex === playerIdx ? "won" : firstKill?.victimIndex === playerIdx ? "lost" : "none",
         kastTags: [...kastTags],
         equipmentValue: economy?.equipmentValue ?? null,
         economyType: economy?.type ?? null
@@ -72,14 +84,30 @@ export function buildPlayerRoundFacts(pkg: DemoPackage): PlayerRoundFact[] {
 }
 
 export function buildPlayerIndicators(pkg: DemoPackage, facts: PlayerRoundFact[]): PlayerIndicatorRow[] {
-  const indicators = pkg.players.map((player) => {
-    const stats = pkg.playerStats.find((row) => row.steamId64 === player.steamId64);
+  const statsMap = new Map(pkg.playerStats.map((row) => [row.playerIndex, row]));
+  const utilityTotals = new Map<string, {
+    utilityDamage: number;
+    flashAssists: number;
+    enemyBlindSeconds: number;
+    teamBlindSeconds: number;
+  }>();
+  for (const fact of buildPlayerRoundUtilityFacts(pkg)) {
+    const total = utilityTotals.get(fact.steamId64) ?? { utilityDamage: 0, flashAssists: 0, enemyBlindSeconds: 0, teamBlindSeconds: 0 };
+    total.utilityDamage += fact.utilityDamage;
+    total.flashAssists += fact.flashAssists;
+    total.enemyBlindSeconds += fact.enemyBlindSeconds;
+    total.teamBlindSeconds += fact.teamBlindSeconds;
+    utilityTotals.set(fact.steamId64, total);
+  }
+
+  const indicators = pkg.players.map((player, playerIdx) => {
+    const stats = statsMap.get(playerIdx);
     const playerFacts = facts.filter((fact) => fact.steamId64 === player.steamId64);
-    const playerKills = pkg.kills.filter((kill) => kill.killerSteamId64 === player.steamId64);
-    const playerDeaths = pkg.kills.filter((kill) => kill.victimSteamId64 === player.steamId64);
-    const playerEconomies = pkg.playerEconomies.filter((row) => row.steamId64 === player.steamId64);
-    const playerClutches = pkg.clutches.filter((row) => row.clutcherSteamId64 === player.steamId64);
-    const playerBlinds = pkg.blinds.filter((row) => row.flasherSteamId64 === player.steamId64);
+    const playerKills = pkg.kills.filter((kill) => kill.killerIndex === playerIdx);
+    const playerDeaths = pkg.kills.filter((kill) => kill.victimIndex === playerIdx);
+    const playerEconomies = pkg.playerEconomies.filter((row) => row.playerIndex === playerIdx);
+    const playerClutches = pkg.clutches.filter((row) => row.clutcherIndex === playerIdx);
+    const utility = utilityTotals.get(player.steamId64) ?? { utilityDamage: 0, flashAssists: 0, enemyBlindSeconds: 0, teamBlindSeconds: 0 };
     const totalRounds = Math.max(playerFacts.length, 1);
     const killsByRound = new Map<number, number>();
     for (const kill of playerKills) {
@@ -91,15 +119,11 @@ export function buildPlayerIndicators(pkg: DemoPackage, facts: PlayerRoundFact[]
     const openingDuels = firstKillCount + firstDeathCount;
     const awpKills = playerKills.filter((kill) => killWeaponName(kill) === "awp").length;
     const sniperKills = playerKills.filter((kill) => ["awp", "ssg08", "scout"].includes(killWeaponName(kill))).length;
-    const utilityDamage = stats?.utilityDamage ?? playerFacts.reduce((sum, fact) => sum + fact.utilityDamage, 0);
-    const flashAssistCount = stats?.flashAssistCount ?? playerFacts.reduce((sum, fact) => sum + fact.flashAssists, 0);
-    const enemyFlashDurationSeconds = stats?.enemyFlashDurationSeconds ?? playerBlinds
-      .filter((blind) => blind.flashedTeamKey && blind.flashedTeamKey !== player.teamKey)
-      .reduce((sum, blind) => sum + blind.durationSeconds, 0);
-    const teamFlashDurationSeconds = stats?.teamFlashDurationSeconds ?? playerBlinds
-      .filter((blind) => blind.flashedTeamKey === player.teamKey && blind.flashedSteamId64 !== player.steamId64)
-      .reduce((sum, blind) => sum + blind.durationSeconds, 0);
-    const grenadeCount = pkg.grenades.filter((grenade) => grenade.throwerSteamId64 === player.steamId64).length;
+    const utilityDamage = stats?.utilityDamage ?? utility.utilityDamage;
+    const flashAssistCount = stats?.flashAssistCount ?? utility.flashAssists;
+    const enemyFlashDurationSeconds = stats?.enemyFlashDurationSeconds ?? utility.enemyBlindSeconds;
+    const teamFlashDurationSeconds = stats?.teamFlashDurationSeconds ?? utility.teamBlindSeconds;
+    const grenadeCount = pkg.grenades.filter((grenade) => grenade.throwerIndex === playerIdx).length;
     const deaths = stats?.deaths ?? playerDeaths.length;
     const kills = stats?.kills ?? playerKills.length;
     const assists = stats?.assists ?? playerFacts.reduce((sum, fact) => sum + fact.assists, 0);
@@ -185,7 +209,7 @@ export function buildPlayerIndicators(pkg: DemoPackage, facts: PlayerRoundFact[]
     } satisfies RRIndicators;
   });
 
-  const rrWeights = rrWeightsV1 as unknown as RRWeights;
+  const rrWeights = hltv2BaselineWeightsV1 as unknown as RRWeights;
   const prismWeights = prismWeightsV1 as unknown as PrismWeights;
   const rrResults = indicators.map((indicator) => computeRR(indicator, rrWeights));
   const rrScores = rrResults.map((result) => result.rr);
@@ -213,22 +237,27 @@ export function buildPlayerIndicators(pkg: DemoPackage, facts: PlayerRoundFact[]
 export function buildScoreboard(
   pkg: DemoPackage,
   rows: PlayerIndicatorRow[],
-  accountRatings: Array<{ signals: AccountSignalsV2; rr: RRResultV2 }>
+  accountRatings: Array<{ signals: RRSignals; rr: AccountRatingResult }>
 ): PlayerScoreboardRow[] {
+  const resolver = createResolverFromPackage(pkg);
   const accountBySteamId = new Map(accountRatings.map((row) => [row.signals.steamId64, row]));
-  const statsBySteamId = new Map(pkg.playerStats.map((row) => [row.steamId64, row]));
+  const statsMap = new Map(pkg.playerStats.map((row) => [row.playerIndex, row]));
   const availability = fieldAvailability(pkg);
   const confidence = fieldConfidence(availability);
   return rows.map((row) => {
     const account = accountBySteamId.get(row.steamId64);
     const accountRr = account?.rr;
     const combatSignals = account?.signals.combat;
-    const stats = statsBySteamId.get(row.steamId64);
-    const playerKills = pkg.kills.filter((kill) => kill.killerSteamId64 === row.steamId64);
+    const playerIdx = resolver.indexOfSteamId(row.steamId64);
+    const stats = playerIdx != null ? statsMap.get(playerIdx) : undefined;
+    const playerKills = playerIdx != null
+      ? pkg.kills.filter((kill) => kill.killerIndex === playerIdx)
+      : [];
     return {
       steamId64: row.steamId64,
       name: row.name,
       teamKey: row.teamKey,
+      indicators: row.indicators,
       kills: row.indicators.kills,
       deaths: row.indicators.deaths,
       assists: row.indicators.assists,
@@ -258,6 +287,7 @@ export function buildScoreboard(
       accountBreakdown: {
         combat: round(accountRr?.accounts.combat ?? 0, 4),
         trade: round(accountRr?.accounts.trade ?? 0, 4),
+        mapControl: round(accountRr?.accounts.mapControl ?? 0, 4),
         clutch: round(accountRr?.accounts.clutch ?? 0, 4),
         objective: round(accountRr?.accounts.objective ?? 0, 4),
         utility: round(accountRr?.accounts.utility ?? 0, 4)

package/src/side-win-rate.test.ts

@@ -0,0 +1,33 @@
+import { describe, expect, it } from "vitest";
+import type { DemoPackage } from "@cs2dak/contract";
+import { buildTeamSideWinRates } from "./side-win-rate";
+
+describe("buildTeamSideWinRates", () => {
+  it("aggregates T/CT win rates for both teams from canonical rounds", () => {
+    const pkg = {
+      rounds: [
+        { teamASide: "ct", teamBSide: "t", winnerTeamKey: "teamA" },
+        { teamASide: "ct", teamBSide: "t", winnerTeamKey: "teamB" },
+        { teamASide: "t", teamBSide: "ct", winnerTeamKey: "teamA" }
+      ]
+    } as DemoPackage;
+
+    expect(buildTeamSideWinRates(pkg)).toEqual({
+      teamA: {
+        ct: { played: 2, won: 1, winRate: 0.5 },
+        t: { played: 1, won: 1, winRate: 1 }
+      },
+      teamB: {
+        t: { played: 2, won: 1, winRate: 0.5 },
+        ct: { played: 1, won: 0, winRate: 0 }
+      }
+    });
+  });
+
+  it("returns empty team summaries when rounds are unavailable", () => {
+    expect(buildTeamSideWinRates({ rounds: [] } as unknown as DemoPackage)).toEqual({
+      teamA: {},
+      teamB: {}
+    });
+  });
+});

package/src/side-win-rate.ts

@@ -0,0 +1,49 @@
+import type { DemoPackage, Side, TeamKey } from "@cs2dak/contract";
+
+export interface SideWinRateStats {
+  played: number;
+  won: number;
+  winRate: number;
+}
+
+export type TeamSideWinRates = Record<TeamKey, Partial<Record<Side, SideWinRateStats>>>;
+
+interface SideRoundResult {
+  side: Side;
+  won: boolean;
+}
+
+function aggregateSideWinRates(rows: SideRoundResult[]): Partial<Record<Side, SideWinRateStats>> {
+  const groups = new Map<Side, { played: number; won: number }>();
+  for (const row of rows) {
+    const group = groups.get(row.side) ?? { played: 0, won: 0 };
+    group.played += 1;
+    if (row.won) group.won += 1;
+    groups.set(row.side, group);
+  }
+
+  return Object.fromEntries(
+    [...groups.entries()].map(([side, stats]) => [
+      side,
+      { ...stats, winRate: stats.played > 0 ? stats.won / stats.played : 0 }
+    ])
+  );
+}
+
+/**
+ * 按 T/CT side 汇总一场比赛中两队的回合胜率。
+ *
+ * 取代产品从数据库行重新拼装的 half-side 聚合；产品只负责选择 DemoPackage。
+ */
+export function buildTeamSideWinRates(pkg: DemoPackage): TeamSideWinRates {
+  return {
+    teamA: aggregateSideWinRates(pkg.rounds.map((round) => ({
+      side: round.teamASide,
+      won: round.winnerTeamKey === "teamA"
+    }))),
+    teamB: aggregateSideWinRates(pkg.rounds.map((round) => ({
+      side: round.teamBSide,
+      won: round.winnerTeamKey === "teamB"
+    })))
+  };
+}