@cs2dak/presentation 1.0.0 → 2.0.0

package/src/workspace.ts

@@ -9,11 +9,15 @@ import {
   type TeamKey,
   type WorkspaceKillEvent,
   type WorkspaceReplayFrame,
+  type WorkspaceReplayLoadout,
+  type WorkspaceReplayRound,
   type WorkspaceSpatialPoint
 } from "@cs2dak/contract";
+import { decodeDelta } from "@cs2dak/contract";
 import { groupBy, nameForSteamId, round, normalizeWeapon, isNamedWeapon } from "./workspace-utils.js";
 import { displayWeaponName } from "./weapons.js";
-import { analyzeDemoPackage, normalizeDemoPackage } from "@cs2dak/core";
+import { activeDamages, analyzeDemoPackage, normalizeDemoPackage } from "@cs2dak/core";
+import { getMapCalibration, hasLowerLevel } from "@cs2dak/maps";
 
 export function buildDemoViewModel(bundle: AnalysisBundle) {
   return {
@@ -22,6 +26,7 @@ export function buildDemoViewModel(bundle: AnalysisBundle) {
     map: {
       name: bundle.mapName,
       radarImageUrl: radarImageUrlForMap(bundle.mapName),
+      lowerRadarImageUrl: lowerRadarImageUrlForMap(bundle.mapName),
       calibrated: bundle.heatmap.length > 0
     },
     scoreline: `${bundle.teams.teamA.score}:${bundle.teams.teamB.score}`,
@@ -62,6 +67,8 @@ export function buildMatchWorkspaceModel(input: unknown): MatchWorkspaceModel {
       { key: "rounds", label: "回合" },
       { key: "players", label: "选手" },
       { key: "economy", label: "经济" },
+      { key: "weapons", label: "武器" },
+      { key: "duels", label: "对位" },
       { key: "map", label: "地图" },
       { key: "replay", label: "回放" }
     ],
@@ -79,7 +86,8 @@ export function buildMatchWorkspaceModel(input: unknown): MatchWorkspaceModel {
       teamAEconomy: roundRow.teamAEconomy,
       teamBEconomy: roundRow.teamBEconomy,
       events: eventsByRound.get(roundRow.roundNumber) ?? [],
-      playerFacts: factsByRound.get(roundRow.roundNumber) ?? []
+      playerFacts: factsByRound.get(roundRow.roundNumber) ?? [],
+      facets: buildRoundFacets(pkg, roundRow.roundNumber)
     })),
     players: bundle.scoreboard.map((row) => ({
       row,
@@ -88,6 +96,7 @@ export function buildMatchWorkspaceModel(input: unknown): MatchWorkspaceModel {
       rrBreakdown: [
         { key: "combat", label: "Combat", value: row.accountBreakdown.combat },
         { key: "trade", label: "Trade", value: row.accountBreakdown.trade },
+        { key: "mapControl", label: "MapControl", value: row.accountBreakdown.mapControl },
         { key: "clutch", label: "Clutch", value: row.accountBreakdown.clutch },
         { key: "objective", label: "Objective", value: row.accountBreakdown.objective },
         { key: "utility", label: "Utility", value: row.accountBreakdown.utility }
@@ -95,16 +104,140 @@ export function buildMatchWorkspaceModel(input: unknown): MatchWorkspaceModel {
       roundFacts: factsByPlayer.get(row.steamId64) ?? []
     })),
     economy: bundle.economy,
+    weapons: buildWorkspaceWeapons(pkg),
+    duels: buildWorkspaceDuels(pkg, bundle),
     map: buildWorkspaceMap(pkg, view.map, bundle.heatmap),
     replay: buildWorkspaceReplay(pkg),
     adminQa: bundle.qa
   });
 }
 
+/** 回合筛选与时间轴锚点的派生事实（v0.2 query-first）。 */
+function buildRoundFacets(pkg: DemoPackage, roundNumber: number) {
+  const kills = pkg.kills
+    .filter((kill) => kill.roundNumber === roundNumber)
+    .sort((a, b) => a.tick - b.tick);
+  const bombs = pkg.bombs.filter((bomb) => bomb.roundNumber === roundNumber);
+  const plant = bombs.find((bomb) => bomb.type === "planted") ?? null;
+  const defuse = bombs.find((bomb) => bomb.type === "defused") ?? null;
+  const clutch = pkg.clutches.find((row) => row.roundNumber === roundNumber) ?? null;
+  const firstKill = kills[0] ?? null;
+
+  const killsByPlayer = new Map<string, number>();
+  for (const kill of kills) {
+    const killerPlayer = kill.killerIndex != null ? pkg.players[kill.killerIndex] : undefined;
+    const victimPlayer = pkg.players[kill.victimIndex];
+    if (!killerPlayer || !victimPlayer || killerPlayer.teamKey === victimPlayer.teamKey) continue;
+    killsByPlayer.set(killerPlayer.steamId64, (killsByPlayer.get(killerPlayer.steamId64) ?? 0) + 1);
+  }
+
+  return {
+    bombSite: plant?.site ?? null,
+    bombPlantTick: plant?.tick ?? null,
+    bombDefuseTick: defuse?.tick ?? null,
+    firstKillTick: firstKill?.tick ?? null,
+    firstKillSteamId64: firstKill && firstKill.killerIndex != null ? (pkg.players[firstKill.killerIndex]?.steamId64 ?? null) : null,
+    firstKillTeamKey: firstKill && firstKill.killerIndex != null ? (pkg.players[firstKill.killerIndex]?.teamKey ?? null) : null,
+    clutch: clutch
+      ? {
+          steamId64: pkg.players[clutch.clutcherIndex]?.steamId64 ?? "",
+          teamKey: pkg.players[clutch.clutcherIndex]?.teamKey ?? "",
+          opponentCount: clutch.opponentCount,
+          won: clutch.won,
+          tick: clutch.tick
+        }
+      : null,
+    maxKillsByOnePlayer: Math.max(0, ...killsByPlayer.values()),
+    wallbangKills: kills.filter((kill) => kill.penetratedObjects > 0).length,
+    throughSmokeKills: kills.filter((kill) => kill.throughSmoke).length
+  };
+}
+
+/** 比赛级武器统计：击杀来自 kills.json，伤害来自 damages.json（healthDamage 口径）。 */
+function buildWorkspaceWeapons(pkg: DemoPackage) {
+  const killsByWeapon = groupBy(
+    pkg.kills.filter((kill) => isNamedWeapon(kill.weapon)),
+    (kill) => normalizeWeapon(kill.weapon)
+  );
+  const damageByWeapon = new Map<string, number>();
+  for (const damage of activeDamages(pkg)) {
+    if (!isNamedWeapon(damage.weapon)) continue;
+    const key = normalizeWeapon(damage.weapon);
+    damageByWeapon.set(key, (damageByWeapon.get(key) ?? 0) + damage.healthDamage);
+  }
+
+  return [...killsByWeapon.entries()]
+    .map(([weapon, kills]) => {
+      const killerCounts = new Map<string, number>();
+      for (const kill of kills) {
+        if (kill.killerIndex == null) continue;
+        const killer = pkg.players[kill.killerIndex];
+        if (killer) killerCounts.set(killer.steamId64, (killerCounts.get(killer.steamId64) ?? 0) + 1);
+      }
+      const topKiller = [...killerCounts.entries()].sort((a, b) => b[1] - a[1])[0] ?? null;
+      const headshots = kills.filter((kill) => kill.headshot).length;
+      return {
+        weapon,
+        label: displayWeaponName(weapon),
+        kills: kills.length,
+        headshotPercent: kills.length > 0 ? round((headshots / kills.length) * 100, 1) : null,
+        damage: damageByWeapon.get(weapon) ?? 0,
+        wallbangKills: kills.filter((kill) => kill.penetratedObjects > 0).length,
+        noScopeKills: kills.filter((kill) => kill.noScope).length,
+        throughSmokeKills: kills.filter((kill) => kill.throughSmoke).length,
+        topKillerName: topKiller ? nameForSteamId(pkg, topKiller[0]) : null,
+        topKillerKills: topKiller ? topKiller[1] : 0
+      };
+    })
+    .sort((a, b) => b.kills - a.kills);
+}
+
+/** 对位：10x10 击杀矩阵（teamA 在前）+ 开局对枪统计（来自 playerRoundFacts）。 */
+function buildWorkspaceDuels(pkg: DemoPackage, bundle: AnalysisBundle) {
+  const players = [...bundle.scoreboard]
+    .sort((a, b) => (a.teamKey === b.teamKey ? b.accountRR - a.accountRR : a.teamKey === "teamA" ? -1 : 1))
+    .map((row) => ({ steamId64: row.steamId64, name: row.name, teamKey: row.teamKey }));
+  const indexBySteamId = new Map(players.map((player, index) => [player.steamId64, index]));
+
+  const matrix = players.map(() => players.map(() => 0));
+  for (const kill of pkg.kills) {
+    if (kill.killerIndex == null) continue;
+    const killer = pkg.players[kill.killerIndex];
+    const victim = pkg.players[kill.victimIndex];
+    if (!killer || !victim) continue;
+    const killerIdx = indexBySteamId.get(killer.steamId64);
+    const victimIdx = indexBySteamId.get(victim.steamId64);
+    if (killerIdx == null || victimIdx == null) continue;
+    matrix[killerIdx][victimIdx] += 1;
+  }
+
+  const factsByPlayer = groupBy(bundle.playerRoundFacts, (fact) => fact.steamId64);
+  const openings = players.map((player) => {
+    const facts = factsByPlayer.get(player.steamId64) ?? [];
+    const openingKills = facts.filter((fact) => fact.openingDuel === "won").length;
+    const openingDeaths = facts.filter((fact) => fact.openingDuel === "lost").length;
+    const total = openingKills + openingDeaths;
+    return {
+      ...player,
+      openingKills,
+      openingDeaths,
+      winRatePercent: total > 0 ? round((openingKills / total) * 100, 1) : null
+    };
+  });
+
+  return { players, matrix, openings };
+}
+
 function radarImageUrlForMap(mapName: string): string | null {
-  const knownMaps = new Set(["de_ancient", "de_anubis", "de_dust2", "de_inferno", "de_mirage", "de_nuke", "de_overpass"]);
+  // 有标定即有底图：apps 的 public/maps/radars/ 与 MAP_CALIBRATIONS 保持同套地图。
   // Relative path so it resolves from both http:// dev server and file:// pywebview.
-  return knownMaps.has(mapName) ? `./maps/radars/${mapName}.png` : null;
+  return getMapCalibration(mapName) ? `./maps/radars/${mapName}.png` : null;
+}
+
+/** 双层地图（标定带 lowerLevelMaxUnits）的下层底图（{map}_lower.png）。 */
+function lowerRadarImageUrlForMap(mapName: string): string | null {
+  const calibration = getMapCalibration(mapName);
+  return calibration && hasLowerLevel(calibration) ? `./maps/radars/${mapName}_lower.png` : null;
 }
 
 function buildWorkspaceKpis(bundle: AnalysisBundle) {
@@ -177,11 +310,11 @@ function sideLabelZh(side: "ct" | "t" | null): string {
 const STORY_COPY = {
   headline: {
     /** 比分差 → 动词。 */
-    verb: (margin: number) => (margin >= 8 ? "碾压" : margin <= 2 ? "险胜" : "拿下"),
+    verb: (margin: number) => (margin >= 8 ? "大比分战胜" : margin <= 2 ? "险胜" : "战胜"),
     comeback: (firstHalf: number, secondHalf: number) =>
-      `上半场只拿到 ${firstHalf} 分被压着打，换边后连下 ${secondHalf} 分完成翻盘`,
+      `上半场拿到 ${firstHalf} 分，换边后取得 ${secondHalf} 分完成比分反超`,
     frontRunner: (firstHalf: number, secondHalf: number) =>
-      `上半场就先声夺人拿下 ${firstHalf} 分，下半场再补 ${secondHalf} 分锁死悬念`,
+      `上半场拿到 ${firstHalf} 分，下半场再取得 ${secondHalf} 分`,
     even: (firstHalf: number, secondHalf: number) =>
       `上半场拿 ${firstHalf} 分、下半场再添 ${secondHalf} 分`,
     overtime: (overtimeWins: number) => `，加时又咬下 ${overtimeWins} 分才分出胜负`,
@@ -193,26 +326,26 @@ const STORY_COPY = {
     context: (sideLabel: string, crossSwitch: boolean, ownedByWinner: boolean) =>
       !ownedByWinner ? "" : crossSwitch ? "横跨换边" : `靠 ${sideLabel} 半场`,
     line: (startRound: number, endRound: number, length: number, team: string, context: string) =>
-      `真正拉开差距的是 R${startRound}-R${endRound} 那波 ${length} 连胜，${team}${context}借此锁定胜局。`
+      `${team} 在 R${startRound}-R${endRound} 取得 ${length} 连胜${context ? `（${context}）` : ""}，这是本场最长连胜段。`
   },
   pistol: {
-    sweep: "这场比赛几乎已经拿下一半。",
-    none: "这场胜利完全是靠后面一分分追回来的。",
-    split: "另一个交还给对手，靠后续长枪局把节奏拉了回来。",
+    sweep: "两次手枪局均取胜。",
+    none: "两次手枪局均未取胜，胜局来自后续回合。",
+    split: "双方各取一次手枪局。",
     line: (total: number, winner: string, wins: number, tail: string) =>
       `${total} 个手枪局 ${winner} 拿下 ${wins} 个，${tail}`
   },
   clutch: {
     line: (who: string, teamTag: string, round: number, opponents: number) =>
-      `最精彩的残局是 ${who}${teamTag}在 R${round} 的 1v${opponents} 残局翻盘，这种回合最能鼓舞士气。`
+      `样本中人数规模最大的残局是 ${who}${teamTag}在 R${round} 完成的 1v${opponents}。`
   },
   entry: {
     line: (name: string, entryKills: number) =>
-      `${name} 是队里首杀最多的选手，${entryKills} 次首杀大多由他先行完成。`
+      `${name} 记录到 ${entryKills} 次首杀，为队内最多。`
   },
   lowBuy: {
     line: (winner: string, count: number, round: number) =>
-      `${winner} 还在 ${count} 个eco或半起中完成了对对手的翻盘（如 R${round}），这种以弱胜强是对对手经济的严重打击。`
+      `${winner} 在 ${count} 个低经济回合中取胜，代表回合为 R${round}。`
   },
   closeout: {
     reason: {
@@ -223,21 +356,22 @@ const STORY_COPY = {
       target_saved: "拖到时间耗尽"
     } as Record<string, string>,
     line: (winner: string, count: number, total: number, reason: string) =>
-      `${winner} 的胜局里有 ${count}/${total} 个靠${reason}收尾，打法偏好相当鲜明。`
+      `${winner} 的胜局中有 ${count}/${total} 个以${reason}结束。`
   },
   mvp: {
     dom: {
-      combat: "纯粹的枪法压制",
-      trade: "默契的补枪联动",
-      clutch: "残局里的收割能力",
-      objective: "对包点目标的推进",
-      utility: "道具开路的支援"
+      combat: "Combat 项",
+      trade: "Trade 项",
+      mapControl: "MapControl 项",
+      clutch: "Clutch 项",
+      objective: "Objective 项",
+      utility: "Utility 项"
     } as Record<string, string>,
     winnerAdrTail: (name: string, adr: string) => `；场均伤害最高的则是 ${name}（ADR ${adr}）`,
     winner: (name: string, kda: string, adr: string, rr: string, dom: string, adrTail: string) =>
-      `胜者这边 ${name} 打得最稳，${kda}、场均 ${adr} 伤害，全场最高的 RR ${rr} 主要来自${dom}${adrTail}。`,
+      `胜方 RR 最高的是 ${name}（${kda}、ADR ${adr}、RR ${rr}），六账户分解中${dom}最突出${adrTail}。`,
     loser: (rr: string, kda: string, name: string, team: string, dom: string) =>
-      `值得一提的是，全场 RR 最高（${rr}，${kda}）的 ${name} 来自落败的 ${team}，凭${dom}撑起了大部分火力，可惜独木难支。`
+      `全场 RR 最高的是落败方 ${team} 的 ${name}（${rr}，${kda}），六账户分解中${dom}最突出。`
   }
 } as const;
 
@@ -415,7 +549,7 @@ function clutchBeat(ctx: StoryContext): StoryBeat | null {
   const won = ctx.pkg.clutches.filter((row) => row.won && (row.opponentCount ?? 0) >= 2);
   if (won.length === 0) return null;
   const top = [...won].sort((a, b) => (b.opponentCount ?? 0) - (a.opponentCount ?? 0))[0]!;
-  const player = ctx.pkg.players.find((row) => row.steamId64 === top.clutcherSteamId64);
+  const player = ctx.pkg.players[top.clutcherIndex];
   const who = player?.name ?? "某选手";
   const teamName = player
     ? player.teamKey === "teamA"
@@ -547,29 +681,15 @@ function buildWorkspaceMap(pkg: DemoPackage, view: ReturnType<typeof buildDemoVi
       y: bomb.position.y,
       z: bomb.position.z,
       roundNumber: bomb.roundNumber,
-      teamKey: bomb.actorTeamKey,
-      steamId64: bomb.actorSteamId64,
+      teamKey: bomb.actorIndex != null ? (pkg.players[bomb.actorIndex]?.teamKey ?? null) : null,
+      steamId64: bomb.actorIndex != null ? (pkg.players[bomb.actorIndex]?.steamId64 ?? null) : null,
       kind: "bomb",
       side: null,
       grenadeType: null
     }));
-  const positionPoints: WorkspaceSpatialPoint[] = (pkg.positions1s ?? [])
-    .filter((row) => row.position && (row.position.x !== 0 || row.position.y !== 0))
-    .map((row) => ({
-      x: row.position?.x ?? 0,
-      y: row.position?.y ?? 0,
-      z: row.position?.z ?? 0,
-      roundNumber: row.roundNumber,
-      teamKey: row.teamKey,
-      steamId64: row.steamId64,
-      kind: "position",
-      side: null,
-      grenadeType: null
-    }));
   const points: WorkspaceSpatialPoint[] = [
     ...heatmap.map((point) => ({ ...point, kind: point.kind })),
-    ...bombPoints,
-    ...positionPoints
+    ...bombPoints
   ];
   const count = (kind: WorkspaceSpatialPoint["kind"]) => points.filter((point) => point.kind === kind).length;
   const hasPositionData = points.length > 0;
@@ -605,51 +725,127 @@ function buildWorkspaceReplay(pkg: DemoPackage) {
       tickrate: null,
       rounds: [],
       capabilities: {
-        hasDefuseKit: false,
-        hasBombPosition: false
+        hasDefuseKit: false
       }
     };
   }
 
   const killsByRound = groupBy(pkg.kills, (k) => k.roundNumber);
+  const grenadesByRound = groupBy(pkg.grenades, (g) => g.roundNumber);
+  const bombsByRound = groupBy(pkg.bombs, (b) => b.roundNumber);
+  const roundsByNumber = new Map(pkg.rounds.map((r) => [r.roundNumber, r]));
+  const endTickByRound = new Map(pkg.rounds.map((r) => [r.roundNumber, r.endTick]));
+  const sortedPackageRounds = [...pkg.rounds].sort((a, b) => a.startTick - b.startTick);
+  const targetEndTickByRound = new Map<number, number>();
+  sortedPackageRounds.forEach((round, index) => {
+    targetEndTickByRound.set(
+      round.roundNumber,
+      sortedPackageRounds[index + 1]?.startTick ?? round.endTick
+    );
+  });
+  const economyByRoundPlayer = new Map(pkg.playerEconomies.map((row) => [`${row.roundNumber}:${row.playerIndex}`, row]));
 
   let hasDefuseKit = false;
-  const rounds = replay.rounds.map((roundRow) => ({
-    roundNumber: roundRow.roundNumber,
-    startTick: roundRow.startTick,
-    tickStep: roundRow.tickStep,
-    frameCount: roundRow.frameCount,
-    kills: buildRoundKills(pkg, killsByRound.get(roundRow.roundNumber) ?? []),
-    players: roundRow.players.map((player) => {
-      const frames: WorkspaceReplayFrame[] = [];
-      for (let index = 0; index < roundRow.frameCount; index += 1) {
-        const flags = player.flags[index] ?? 0;
-        const frame = {
-          tick: roundRow.startTick + index * roundRow.tickStep,
-          x: player.x[index] ?? 0,
-          y: player.y[index] ?? 0,
-          z: player.z[index] ?? 0,
-          yaw: player.yaw[index] ?? 0,
-          hp: player.hp[index] ?? 0,
-          weapon: weaponNameForIndex(replay.weaponDict, player.weapon[index] ?? -1),
-          alive: (flags & 1) !== 0,
-          flashed: (flags & 8) !== 0,
-          hasDefuseKit: (flags & 4) !== 0
-        };
-        if (frame.hasDefuseKit) {
-          hasDefuseKit = true;
+  const rounds = replay.rounds.map((roundRow) => {
+    const sourceRound = roundsByNumber.get(roundRow.roundNumber);
+    const sideForTeam = (teamKey: TeamKey | null | undefined) => {
+      if (!sourceRound || !teamKey) return null;
+      return teamKey === "teamA" ? sourceRound.teamASide : sourceRound.teamBSide;
+    };
+
+    const officialEndTick = endTickByRound.get(roundRow.roundNumber);
+    const targetEndTick = targetEndTickByRound.get(roundRow.roundNumber) ?? officialEndTick;
+
+    return {
+      roundNumber: roundRow.roundNumber,
+      startTick: roundRow.startTick,
+      freezeEndTick: sourceRound?.freezeEndTick ?? roundRow.startTick,
+      tickStep: roundRow.tickStep,
+      frameCount: roundRow.frameCount,
+      officialEndTick,
+      targetEndTick,
+      kills: buildRoundKills(pkg, killsByRound.get(roundRow.roundNumber) ?? []),
+      grenades: (grenadesByRound.get(roundRow.roundNumber) ?? []).map((row) => ({
+        grenade: row.grenade,
+        throwerSide: sideForTeam(pkg.players[row.throwerIndex]?.teamKey),
+        throwTick: row.throwTick,
+        effectTick: row.effectTick,
+        destroyTick: row.destroyTick,
+        throwX: row.throwPosition.x,
+        throwY: row.throwPosition.y,
+        effectX: row.effectPosition.x,
+        effectY: row.effectPosition.y,
+        effectZ: row.effectPosition.z
+      })),
+      // v2.3+ 导出包才带飞行轨迹；旧包置空，渲染端按"无数据"处理
+      // v3 起 x/y/z 为差分编码（首元素绝对值 + 后续 delta），前缀和解码后 × coordScale 还原游戏单位
+      projectiles: (roundRow.projectiles ?? []).map((proj) => ({
+        grenade: proj.grenade,
+        startTick: proj.startTick,
+        x: decodeDelta(proj.x).map((v) => v * (replay.meta.coordScale || 1)),
+        y: decodeDelta(proj.y).map((v) => v * (replay.meta.coordScale || 1)),
+        z: decodeDelta(proj.z ?? []).map((v) => v * (replay.meta.coordScale || 1))
+      })),
+      bomb: buildRoundBomb(bombsByRound.get(roundRow.roundNumber) ?? []),
+      groundBombs: buildGroundBombs(
+        bombsByRound.get(roundRow.roundNumber) ?? [],
+        targetEndTick ?? roundRow.startTick + roundRow.frameCount * roundRow.tickStep
+      ),
+      groundDefusers: buildGroundDefusers(
+        roundRow,
+        replay.meta.coordScale || 1,
+        sourceRound?.freezeEndTick ?? roundRow.startTick,
+        targetEndTick ?? roundRow.startTick + roundRow.frameCount * roundRow.tickStep
+      ),
+      players: roundRow.players.map((player) => {
+        // v3 起 x/y/z/yaw 为差分编码，flash 改为独立列（0.1 秒单位，flags 不再含致盲位）
+        const coordScale = replay.meta.coordScale || 1;
+        const angleScale = replay.meta.angleScale || 1;
+        const xs = decodeDelta(player.x);
+        const ys = decodeDelta(player.y);
+        const zs = decodeDelta(player.z);
+        const yaws = decodeDelta(player.yaw);
+        const replayPlayer = pkg.players[player.playerIndex];
+        const economy = economyByRoundPlayer.get(`${roundRow.roundNumber}:${player.playerIndex}`);
+        // 此位选手本回合是否戴头盔（player-economies 逐回合数据，全帧相同）
+        const hasHelmet = economy?.hasHelmet ?? false;
+        const loadout = loadoutForEconomy(economy);
+        const frames: WorkspaceReplayFrame[] = [];
+        for (let index = 0; index < roundRow.frameCount; index += 1) {
+          const flags = player.flags[index] ?? 0;
+          const frame = {
+            tick: roundRow.startTick + index * roundRow.tickStep,
+            x: (xs[index] ?? 0) * coordScale,
+            y: (ys[index] ?? 0) * coordScale,
+            z: (zs[index] ?? 0) * coordScale,
+            yaw: (yaws[index] ?? 0) / angleScale,
+            hp: player.hp[index] ?? 0,
+            armor: player.armor?.[index] ?? 0,
+            weapon: weaponNameForIndex(replay.weaponDict, player.weapon[index] ?? -1),
+            grenades: normalizeHeldGrenades((player as { grenades?: unknown[][] }).grenades?.[index]),
+            alive: (flags & 1) !== 0,
+            flashed: (player.flash?.[index] ?? 0) > 0,
+            flashRemainingSeconds: Math.max(0, (player.flash?.[index] ?? 0) / 10),
+            hasDefuseKit: (flags & 4) !== 0,
+            hasBomb: (flags & 2) !== 0,
+            hasHelmet
+          };
+          if (frame.hasDefuseKit) {
+            hasDefuseKit = true;
+          }
+          frames.push(frame);
         }
-        frames.push(frame);
-      }
-      return {
-        steamId64: player.steamId64,
-        name: nameForSteamId(pkg, player.steamId64) ?? player.steamId64,
-        teamKey: player.teamKey,
-        side: player.side,
-        frames
-      };
-    })
-  }));
+        return {
+          steamId64: replayPlayer?.steamId64 ?? String(player.playerIndex),
+          name: replayPlayer?.name ?? `Player ${player.playerIndex}`,
+          teamKey: replayPlayer?.teamKey ?? "teamA",
+          side: sideForTeam(replayPlayer?.teamKey) ?? "t",
+          loadout,
+          frames
+        };
+      })
+    };
+  });
 
   return {
     available: true,
@@ -657,12 +853,118 @@ function buildWorkspaceReplay(pkg: DemoPackage) {
     tickrate: replay.meta.tickrate,
     rounds,
     capabilities: {
-      hasDefuseKit,
-      hasBombPosition: false
+      hasDefuseKit
     }
   };
 }
 
+const HELD_GRENADE_TYPES = new Set(["flashbang", "smoke", "molotov", "incendiary", "hegrenade", "decoy"]);
+
+function loadoutForEconomy(economy: DemoPackage["playerEconomies"][number] | undefined): WorkspaceReplayLoadout {
+  const maybeGrenades = (economy as { grenades?: unknown } | undefined)?.grenades;
+  const rawGrenades = Array.isArray(maybeGrenades) ? maybeGrenades : [];
+  return {
+    primaryWeapon: economy?.primaryWeapon ?? null,
+    secondaryWeapon: economy?.secondaryWeapon ?? null,
+    grenadeCount: economy?.grenadeCount ?? 0,
+    grenades: rawGrenades.filter((value): value is WorkspaceReplayLoadout["grenades"][number] =>
+      typeof value === "string" && HELD_GRENADE_TYPES.has(value)
+    )
+  };
+}
+
+function normalizeHeldGrenades(value: unknown): WorkspaceReplayLoadout["grenades"] {
+  if (!Array.isArray(value)) return [];
+  return value.filter((item): item is WorkspaceReplayLoadout["grenades"][number] =>
+    typeof item === "string" && HELD_GRENADE_TYPES.has(item)
+  );
+}
+
+/** 从 bombs.json 取该回合 C4 锚点：plant 位置定格，defuse/explode 决定终态。 */
+function buildRoundBomb(events: DemoPackage["bombs"]): WorkspaceReplayRound["bomb"] {
+  const plant = events.find((event) => event.type === "planted");
+  if (!plant) return null;
+  return {
+    plantTick: plant.tick,
+    x: plant.position.x,
+    y: plant.position.y,
+    z: plant.position.z,
+    defuseTick: events.find((event) => event.type === "defused")?.tick ?? null,
+    explodeTick: events.find((event) => event.type === "exploded")?.tick ?? null
+  };
+}
+
+/** dropped → 下一次 picked_up / planted / exploded / defused 构成一段地面区间。 */
+function buildGroundBombs(events: DemoPackage["bombs"], roundEndTick: number): WorkspaceReplayRound["groundBombs"] {
+  const sorted = [...events].sort((a, b) => a.tick - b.tick);
+  const intervals: { startTick: number; endTick: number; x: number; y: number; z: number }[] = [];
+  for (let i = 0; i < sorted.length; i += 1) {
+    if (sorted[i].type !== "dropped") continue;
+    const drop = sorted[i];
+    // 找下一个相关事件：picked_up / planted / defused / exploded
+    const next = sorted.slice(i + 1).find((e) =>
+      e.type === "picked_up" || e.type === "planted" || e.type === "defused" || e.type === "exploded"
+    );
+    intervals.push({
+      startTick: drop.tick,
+      endTick: next?.tick ?? roundEndTick,
+      x: drop.position.x,
+      y: drop.position.y,
+      z: drop.position.z
+    });
+  }
+  return intervals;
+}
+
+/**
+ * 拆弹器掉落区间：CS2 中 kit 只在持有者阵亡时落地（不可手动丢弃）。
+ * 逐帧扫描每名玩家的存活位（flags&1）与持 kit 位（flags&4）：
+ *  - 阵亡掉落：上一帧"存活且持 kit" → 本帧"阵亡" ⇒ 在上一帧位置生成一个落地 kit；
+ *  - 被捡起：某玩家存活且 kit 由无变有（freezeEnd 之后，排除买阶段初始持有）⇒ 关闭最早一个落地 kit（FIFO）。
+ * 未被捡起的落地 kit 持续到回合结束（符合"钳子一直留在地上"）。
+ */
+function buildGroundDefusers(
+  roundRow: NonNullable<DemoPackage["replay"]>["rounds"][number],
+  coordScale: number,
+  freezeEndTick: number,
+  roundEndTick: number
+): WorkspaceReplayRound["groundDefusers"] {
+  const decoded = roundRow.players.map((p) => ({
+    x: decodeDelta(p.x),
+    y: decodeDelta(p.y),
+    z: decodeDelta(p.z),
+    flags: p.flags
+  }));
+  const result: WorkspaceReplayRound["groundDefusers"] = [];
+  const active: Array<{ startTick: number; x: number; y: number; z: number }> = [];
+  for (let i = 1; i < roundRow.frameCount; i += 1) {
+    const tick = roundRow.startTick + i * roundRow.tickStep;
+    if (tick < freezeEndTick) continue;
+    for (const p of decoded) {
+      const prev = p.flags[i - 1] ?? 0;
+      const cur = p.flags[i] ?? 0;
+      const prevAlive = (prev & 1) !== 0;
+      const prevKit = (prev & 4) !== 0;
+      const curAlive = (cur & 1) !== 0;
+      const curKit = (cur & 4) !== 0;
+      if (prevAlive && prevKit && !curAlive) {
+        active.push({
+          startTick: tick,
+          x: (p.x[i - 1] ?? 0) * coordScale,
+          y: (p.y[i - 1] ?? 0) * coordScale,
+          z: (p.z[i - 1] ?? 0) * coordScale
+        });
+      }
+      if (curAlive && !prevKit && curKit && active.length > 0) {
+        const dropped = active.shift()!;
+        result.push({ ...dropped, endTick: tick });
+      }
+    }
+  }
+  for (const dropped of active) result.push({ ...dropped, endTick: roundEndTick });
+  return result;
+}
+
 function weaponNameForIndex(weaponDict: string[], index: number): string | null {
   const raw = index >= 0 ? weaponDict[index] ?? null : null;
   if (!raw) {
@@ -679,18 +981,28 @@ function buildRoundKills(pkg: DemoPackage, kills: DemoPackage["kills"]): Workspa
   return kills.map((kill, index) => {
     const activeRaw = kill.killerActiveWeapon;
     const weaponRaw = activeRaw && isNamedWeapon(normalizeWeapon(activeRaw)) ? activeRaw : kill.weapon;
+    const killerSteamId = kill.killerIndex != null ? pkg.players[kill.killerIndex]?.steamId64 ?? null : null;
+    const victimSteamId = pkg.players[kill.victimIndex]?.steamId64 ?? "";
+    const killerTeamKey = kill.killerIndex != null ? (pkg.players[kill.killerIndex]?.teamKey ?? null) : null;
     return {
       id: `kf-${kill.roundNumber}-${kill.tick}-${index}`,
       tick: kill.tick,
-      killerName: nameForSteamId(pkg, kill.killerSteamId64),
-      killerTeamKey: kill.killerTeamKey,
-      victimName: nameForSteamId(pkg, kill.victimSteamId64) ?? kill.victimSteamId64,
+      killerName: nameForSteamId(pkg, killerSteamId),
+      killerTeamKey,
+      victimName: nameForSteamId(pkg, victimSteamId) ?? victimSteamId,
       weapon: displayWeaponName(weaponRaw),
       headshot: kill.headshot,
       throughSmoke: kill.throughSmoke,
       noScope: kill.noScope,
       flashAssist: kill.flashAssist,
-      tradeKill: kill.tradeKill
+      tradeKill: kill.tradeKill,
+      wallbang: kill.penetratedObjects > 0,
+      killerX: kill.killerPosition?.x ?? null,
+      killerY: kill.killerPosition?.y ?? null,
+      killerZ: kill.killerPosition?.z ?? null,
+      victimX: kill.victimPosition.x,
+      victimY: kill.victimPosition.y,
+      victimZ: kill.victimPosition.z
     };
   });
 }

package/src/labels.ts

@@ -1,3 +0,0 @@
-export function sideLabel(side: string): string {
-  return side === "t" ? "进攻方" : "防守方";
-}