@cs2dak/maps 0.2.1 → 1.0.0

package/src/site-entry-chokes.ts

@@ -0,0 +1,234 @@
+import { getPrimaryCalloutRegion } from "./callout-names.js";
+
+export type SiteTarget = "a" | "b";
+export type SiteEntryKind = "canonical" | "split" | "deep_wrap";
+
+export interface SiteEntryFamilyDefinition {
+  id: string;
+  target: SiteTarget;
+  /** 首次进入包点前可作为物理入口边界的 callout。 */
+  entryCallouts: readonly string[];
+  kind: SiteEntryKind;
+}
+
+export interface SiteRouteMarkerDefinition {
+  id: string;
+  target: SiteTarget;
+  /** 比物理进包边界更早、用于区分宏观路线方向的节点。 */
+  callouts: readonly string[];
+  kind: SiteEntryKind;
+}
+
+export interface MapSiteSemantics {
+  entries: readonly SiteEntryFamilyDefinition[];
+  routeMarkers?: readonly SiteRouteMarkerDefinition[];
+}
+
+export interface ResolvedSiteEntry {
+  target: SiteTarget;
+  /** 真实进包边界；未命中人工入口表时保持 null。 */
+  entryChokeId: string | null;
+  entryCallout: string | null;
+  /** 宏观路线方向；没有独立 marker 时与 entryChokeId 相同。 */
+  routeFamilyId: string | null;
+  routeMarkerCallout: string | null;
+  kind: SiteEntryKind | null;
+}
+
+/**
+ * 七图人工核实的包点入口语义。
+ *
+ * 这里只固化稳定地图知识，不保存 demo 频率、完整动线或战术结论。
+ * Dust2/Overpass 的 routeMarkers 用于表达“路线方向早于真实进包边界”。
+ */
+export const SITE_ENTRY_SEMANTICS: Record<string, MapSiteSemantics> = {
+  de_ancient: {
+    entries: [
+      entry("a_main", "a", ["MainHall"]),
+      entry("a_side_hall", "a", ["SideHall"], "split"),
+      entry("a_ct_spawn", "a", ["CTSpawn"], "deep_wrap"),
+      entry("b_ramp", "b", ["Ramp"]),
+      entry("b_side_entrance", "b", ["SideEntrance"], "split"),
+      entry("b_alley", "b", ["Alley"], "deep_wrap"),
+    ],
+  },
+  de_anubis: {
+    entries: [
+      entry("a_main", "a", ["Main", "Fountain"]),
+      entry("a_walkway", "a", ["Walkway"], "split"),
+      entry("a_heaven", "a", ["Heaven"], "deep_wrap"),
+      entry("b_outside", "b", ["OutsideLong"]),
+      entry("b_connector", "b", ["Connector"], "split"),
+      entry("b_bricks", "b", ["Bricks"], "split"),
+      entry("b_alley", "b", ["Alley"], "deep_wrap"),
+    ],
+  },
+  de_dust2: {
+    entries: [
+      entry("a_short_entry", "a", ["ExtendedA"]),
+      entry("a_long_entry", "a", ["ARamp"]),
+      entry("b_upper_tunnel", "b", ["UpperTunnel"]),
+      entry("b_mid_doors", "b", ["BDoors", "Hole"], "split"),
+    ],
+    routeMarkers: [
+      marker("a_short_route", "a", ["ShortStairs"]),
+      marker("a_long_route", "a", ["LongA"]),
+    ],
+  },
+  de_inferno: {
+    entries: [
+      entry("a1", "a", ["TopofMid", "Quad"]),
+      entry("a2", "a", ["Balcony"]),
+      entry("a_connector", "a", ["Arch", "Library"], "split"),
+      entry("b_banana", "b", ["Banana"]),
+      entry("b_ruins", "b", ["Ruins"], "deep_wrap"),
+    ],
+  },
+  de_mirage: {
+    entries: [
+      entry("a_ramp", "a", ["TRamp"]),
+      entry("a_palace", "a", ["PalaceInterior", "Scaffolding"]),
+      entry("a_connector", "a", ["Connector"], "split"),
+      entry("a_jungle", "a", ["Jungle"], "deep_wrap"),
+      entry("b_apartments", "b", ["Apartments", "Truck"]),
+      entry("b_short", "b", ["Catwalk"], "split"),
+      entry("b_market", "b", ["Shop"], "deep_wrap"),
+    ],
+  },
+  de_nuke: {
+    entries: [
+      entry("a_hut", "a", ["Hut"]),
+      entry("a_mini", "a", ["Mini"]),
+      entry("a_squeaky", "a", ["Squeaky"]),
+      entry("a_vents", "a", ["Vents"], "deep_wrap"),
+      entry("a_heaven", "a", ["Heaven", "Rafters"], "deep_wrap"),
+      entry("b_ramp", "b", ["Ramp"]),
+      entry("b_decon", "b", ["Decon"]),
+      entry("b_tunnels", "b", ["Tunnels", "Observation"], "deep_wrap"),
+    ],
+  },
+  de_overpass: {
+    entries: [
+      entry("a_lower_park", "a", ["LowerPark"]),
+      entry("a_upper_park", "a", ["UpperPark"]),
+      entry("a_bank", "a", ["Lobby", "StorageRoom", "Stairs", "BackofA"], "deep_wrap"),
+      entry("b_monster", "b", ["Canal"]),
+      entry("b_short", "b", ["Construction", "Bridge", "Water"]),
+      entry("b_snipers_walkway", "b", ["SnipersNest", "Walkway"], "deep_wrap"),
+    ],
+    routeMarkers: [
+      marker("b_snipers_walkway_route", "b", ["SnipersNest", "Walkway"], "deep_wrap"),
+    ],
+  },
+};
+
+function entry(
+  id: string,
+  target: SiteTarget,
+  entryCallouts: readonly string[],
+  kind: SiteEntryKind = "canonical",
+): SiteEntryFamilyDefinition {
+  return { id, target, entryCallouts, kind };
+}
+
+function marker(
+  id: string,
+  target: SiteTarget,
+  callouts: readonly string[],
+  kind: SiteEntryKind = "canonical",
+): SiteRouteMarkerDefinition {
+  return { id, target, callouts, kind };
+}
+
+function lastMatch<T extends { callouts?: readonly string[]; entryCallouts?: readonly string[] }>(
+  definitions: readonly T[],
+  path: readonly string[],
+): { definition: T; callout: string; index: number } | null {
+  let best: { definition: T; callout: string; index: number } | null = null;
+  for (const definition of definitions) {
+    const aliases = definition.entryCallouts ?? definition.callouts ?? [];
+    for (let index = path.length - 1; index >= 0; index -= 1) {
+      const callout = path[index];
+      if (callout && aliases.includes(callout) && (!best || index > best.index)) {
+        best = { definition, callout, index };
+        break;
+      }
+    }
+  }
+  return best;
+}
+
+/** 沿路径正序，第一个命中任一 definition 标志 callout 的位置（最早途经点）。 */
+function firstMatch<T extends { callouts?: readonly string[]; entryCallouts?: readonly string[] }>(
+  definitions: readonly T[],
+  path: readonly string[],
+): { definition: T; callout: string; index: number } | null {
+  for (let index = 0; index < path.length; index += 1) {
+    const callout = path[index];
+    for (const definition of definitions) {
+      const aliases = definition.entryCallouts ?? definition.callouts ?? [];
+      if (callout && aliases.includes(callout)) return { definition, callout, index };
+    }
+  }
+  return null;
+}
+
+/**
+ * 进包前「最后一段连续朝该站推进」的轨迹：从进包点往回收，
+ * 只要还在该站区域（或命中进点标志）就并入，一旦折返到异区即截断。
+ * 用于剔除开局在某口子架枪/控图后折返、最终从别处进包造成的误判。
+ */
+function approachSegment(
+  mapName: string,
+  target: SiteTarget,
+  prefix: readonly string[],
+  entries: readonly SiteEntryFamilyDefinition[],
+): string[] {
+  const segment: string[] = [];
+  for (let index = prefix.length - 1; index >= 0; index -= 1) {
+    const callout = prefix[index]!;
+    const onApproach =
+      getPrimaryCalloutRegion(mapName, callout) === target ||
+      entries.some((definition) => definition.entryCallouts.includes(callout));
+    if (!onApproach) break;
+    segment.unshift(callout);
+  }
+  return segment;
+}
+
+export function resolveSiteEntry(
+  mapName: string,
+  target: SiteTarget,
+  callouts: readonly string[],
+): ResolvedSiteEntry {
+  const semantics = SITE_ENTRY_SEMANTICS[mapName];
+  const siteCallout = target === "a" ? "BombsiteA" : "BombsiteB";
+  const siteIndex = callouts.indexOf(siteCallout);
+  const prefix = siteIndex >= 0 ? callouts.slice(0, siteIndex) : callouts;
+  const entries = semantics?.entries.filter((definition) => definition.target === target) ?? [];
+  // 判定点 = 进包前最终冲包段里「最早」命中的进点口子：经过更早分叉（如 TRamp=A1）的
+  // 优先于进包边界（殿=A2），且折返到异区前的开局停留不计入。
+  const entryMatch = firstMatch(entries, approachSegment(mapName, target, prefix, entries));
+  const routeMatch = lastMatch(
+    semantics?.routeMarkers?.filter((definition) => definition.target === target) ?? [],
+    prefix,
+  );
+  const entryDefinition = entryMatch?.definition;
+  const routeDefinition = routeMatch?.definition;
+  return {
+    target,
+    entryChokeId: entryDefinition?.id ?? null,
+    entryCallout: entryMatch?.callout ?? null,
+    routeFamilyId: routeDefinition?.id ?? entryDefinition?.id ?? null,
+    routeMarkerCallout: routeMatch?.callout ?? entryMatch?.callout ?? null,
+    kind: routeDefinition?.kind ?? entryDefinition?.kind ?? null,
+  };
+}
+
+export function siteEntryChokeId(
+  mapName: string,
+  target: SiteTarget,
+  callouts: readonly string[],
+): string | null {
+  return resolveSiteEntry(mapName, target, callouts).entryChokeId;
+}

package/src/site-entry-lexicon.ts

@@ -0,0 +1,131 @@
+// 进点路线「地道叫法」词典（手填真相源）。
+//
+// 定位：把 (地图, 包点, 进点 chokeId 组合) 映射到队内/解说常用的中文证据描述，
+//       只供进点 evidence 展示，不得用于主聚类身份或主战术名。combo 的 chokeId 取自 site-entry-chokes.ts 的 entry id，
+//       字母序、以 + 连接（与 SiteEntryFact.distinctEntryChokeIds 排序一致）。
+// 来源：158 场真实 demo（科隆 Major Stage1 + pro + NJU）统计出的反复出现组合（≥3 次）。
+// 填法：只填每条的 cn（地道叫法，如「走A大」「甜甜圈夹A」「交道打一波」），格式无需改动。
+//       cn 留空的组合，展示层回退为入口 callout 组合，不会自动拍成战术名称。
+
+export interface EntryRouteName {
+  /** 进点 chokeId 组合（字母序 + 连接）。 */
+  combo: string;
+  /** 地道叫法，留空待填。 */
+  cn: string;
+}
+
+/** 取某组合的 evidence 文案；未收录或未填返回空串（由展示层兜底）。 */
+export function entryRouteCn(mapName: string, site: "a" | "b", combo: string): string {
+  return SITE_ENTRY_LEXICON[mapName]?.[site]?.find((row) => row.combo === combo)?.cn ?? "";
+}
+
+export const SITE_ENTRY_LEXICON: Record<string, Partial<Record<"a" | "b", EntryRouteName[]>>> = {
+  de_ancient: {
+    a: [
+      { combo: "a_main", cn: "A厅爆A" },                                // 163次 · A厅
+      { combo: "a_main+a_side_hall", cn: "甜甜圈夹A" },                    //  50次 · A厅 + 甜甜圈
+      { combo: "a_side_hall", cn: "甜甜圈进A" },                           //  46次 · 甜甜圈
+      { combo: "a_ct_spawn", cn: "警家入侵A包" },                            //  12次 · 警家
+      { combo: "a_ct_spawn+a_main", cn: "警家夹A" },                     //   9次 · 警家 + A厅
+      { combo: "a_ct_spawn+a_side_hall", cn: "警家甜甜圈夹A" },                //   6次 · 警家 + 甜甜圈
+    ],
+    b: [
+      { combo: "b_ramp", cn: "B坡爆B" },                                // 192次 · B坡
+      { combo: "b_ramp+b_side_entrance", cn: "黑屋夹B" },                //  79次 · B坡 + 黑屋
+      { combo: "b_side_entrance", cn: "黑屋打B" },                       //  24次 · 黑屋
+      { combo: "b_alley+b_ramp", cn: "底线夹B" },                        //  10次 · 底线 + B坡
+      { combo: "b_alley", cn: "底线转B" },                               //   8次 · 底线
+    ],
+  },
+  de_anubis: {
+    a: [
+      { combo: "a_main", cn: "A厅爆A" },                                //  35次 · A厅/喷泉
+      { combo: "a_main+a_walkway", cn: "中路夹A" },                      //  12次 · A厅/喷泉 + A连
+      { combo: "a_walkway", cn: "中路进A" },                             //  11次 · A连
+    ],
+    b: [
+      { combo: "b_connector+b_outside", cn: "黑屋夹B" },                 //  42次 · 黑屋 + B外
+      { combo: "b_outside", cn: "B外爆B" },                             //  32次 · B外
+      { combo: "b_connector", cn: "黑屋打B" },                           //   8次 · 黑屋
+      { combo: "b_bricks+b_outside", cn: "中路夹B" },                    //   7次 · B连阳光房 + B外
+      { combo: "b_bricks", cn: "中路进B" },                              //   4次 · B连阳光房
+    ],
+  },
+  de_dust2: {
+    a: [
+      { combo: "a_short_entry", cn: "A小爆弹" },                         // 135次 · A小过点
+      { combo: "a_long_entry", cn: "打A大" },                          //  93次 · A斜坡
+      { combo: "a_long_entry+a_short_entry", cn: "夹A" },            //  16次 · A斜坡 + A小过点
+    ],
+    b: [
+      { combo: "b_upper_tunnel", cn: "爆B" },                        // 178次 · B洞
+      { combo: "b_mid_doors+b_upper_tunnel", cn: "夹B" },            //  50次 · B门/狗洞 + B洞
+      { combo: "b_mid_doors", cn: "中路打B" },                           //  21次 · B门/狗洞
+    ],
+  },
+  de_inferno: {
+    a: [
+      { combo: "a1", cn: "打A1" },                                    // 118次 · 中路/马棚
+      { combo: "a1+a_connector", cn: "链接夹A" },                        //  59次 · 中路/马棚 + 拱门/书房
+      { combo: "a1+a2", cn: "A1A2协同" },                                 //  53次 · 中路/马棚 + 阳台
+      { combo: "a2", cn: "飞二楼" },                                    //  22次 · 阳台
+      { combo: "a_connector", cn: "链接打A" },                           //  14次 · 拱门/书房
+      { combo: "a2+a_connector", cn: "A2链接协同" },                        //  10次 · 阳台 + 拱门/书房
+      { combo: "a1+a2+a_connector", cn: "链接夹A" },                     //   9次 · 中路/马棚 + 阳台 + 拱门/书房
+    ],
+    b: [
+      { combo: "b_banana", cn: "蕉道一波" },                              // 256次 · 香蕉道
+      { combo: "b_banana+b_ruins", cn: "链接夹B" },                      //  15次 · 香蕉道 + 警家教堂
+      { combo: "b_ruins", cn: "链接转B" },                               //   3次 · 警家教堂
+    ],
+  },
+  de_mirage: {
+    a: [
+      { combo: "a_palace", cn: "A2展开" },                              // 182次 · A二楼/A2上下
+      { combo: "a_connector+a_palace", cn: "拱门夹A" },                  //  77次 · 拱门 + A二楼/A2上下
+      { combo: "a_connector", cn: "拱门进A" },                           //  36次 · 拱门
+      { combo: "a_connector+a_jungle+a_palace", cn: "拱门jungle夹A" },         //  10次 · 拱门 + Jungle + A二楼/A2上下
+      { combo: "a_connector+a_jungle", cn: "拱门Jungle展开" },                  //   5次 · 拱门 + Jungle
+    ],
+    b: [
+      { combo: "b_apartments", cn: "B2爆弹" },                          // 107次 · B二楼/白车
+      { combo: "b_apartments+b_short", cn: "B小夹B" },                  //  55次 · B二楼/白车 + B小
+      { combo: "b_short", cn: "B小进B" },                               //  20次 · B小
+      { combo: "b_market", cn: "超市夹B" },                              //   3次 · 超市
+    ],
+  },
+  de_nuke: {
+    a: [
+      { combo: "a_squeaky", cn: "铁门展开进A" },                             //  56次 · 铁门房
+      { combo: "a_hut+a_squeaky", cn: "爆A" },                       //  55次 · 黄房 + 铁门房
+      { combo: "a_hut", cn: "黄房进A" },                                 //  30次 · 黄房
+      { combo: "a_mini+a_squeaky", cn: "正门夹A" },                      //  20次 · 正门 + 铁门房
+      { combo: "a_mini", cn: "正门进A" },                                //  19次 · 正门
+      { combo: "a_hut+a_mini", cn: "正门夹A" },                          //  15次 · 黄房 + 正门
+      { combo: "a_hut+a_mini+a_squeaky", cn: "正门夹A" },                //   9次 · 黄房 + 正门 + 铁门房
+      { combo: "a_heaven", cn: "三楼进A" },                              //   5次 · 三楼/三楼横梁
+      { combo: "a_heaven+a_mini", cn: "正门三楼同步" },                       //   3次 · 三楼/三楼横梁 + 正门
+    ],
+    b: [
+      { combo: "b_ramp", cn: "铁板进B" },                                //  51次 · 铁板
+      { combo: "b_decon+b_tunnels", cn: "K1进B" },                     //  28次 · 死门 + K1地下/控制室
+      { combo: "b_decon", cn: "死门进B" },                               //  21次 · 死门
+      { combo: "b_tunnels", cn: "活门控制室进B" },                             //  19次 · K1地下/控制室
+      { combo: "b_decon+b_ramp", cn: "铁板死门夹B" },                        //   8次 · 死门 + 铁板
+      { combo: "b_ramp+b_tunnels", cn: "铁板活门夹B" },                      //   6次 · 铁板 + K1地下/控制室
+      { combo: "b_decon+b_ramp+b_tunnels", cn: "三点同步夹B" },              //   3次 · 死门 + 铁板 + K1地下/控制室
+    ],
+  },
+  de_overpass: {
+    a: [
+      { combo: "a_lower_park", cn: "A小爆弹" },                          //  23次 · A小厕所
+      { combo: "a_upper_park", cn: "A大爆弹" },                          //  21次 · A大厕所
+      { combo: "a_lower_park+a_upper_park", cn: "夹A" },             //  18次 · A小爆弹 + A大爆弹
+    ],
+    b: [
+      { combo: "b_monster+b_short", cn: "工地长管夹B" },                     //  31次 · 长管 + B小/桥
+      { combo: "b_monster", cn: "长管爆B" },                             //  22次 · 长管
+      { combo: "b_short", cn: "B小打B" },                               //  14次 · B小/桥
+    ],
+  },
+};

package/src/tri-assets.ts

@@ -0,0 +1,72 @@
+/**
+ * tri-assets — runtime .tri loader（Node.js only）
+ *
+ * .tri 文件是 awpy 从 CS2 .vphys 导出的三角形流（每三角形 9×f32=36B），
+ * 7 图约 207MB，太大不进 git。通过 `awpy get tris` 下载到本地目录后，
+ * 本模块按需读取、解析、构建 BVH 并缓存。
+ *
+ * DAK Studio 浏览器端不经过此 Node 路径；开发/桌面端通过 HTTP 按需加载 `.tri`。
+ */
+
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { buildTriangleBvh, parseAwpyTri, type TriangleBvh } from "./visibility.js";
+
+/** 可通过环境变量 AWPY_TRIS_DIR 覆盖默认路径。 */
+const DEFAULT_TRIS_DIR = join(
+  process.env.HOME ?? process.env.USERPROFILE ?? "~",
+  ".awpy",
+  "tris",
+);
+
+const triBvhCache = new Map<string, TriangleBvh | null>();
+
+function resolveTriPath(mapName: string): string {
+  const dir = process.env.AWPY_TRIS_DIR ?? DEFAULT_TRIS_DIR;
+  return join(dir, `${mapName}.tri`);
+}
+
+/**
+ * 按需加载指定地图的 .tri 文件并构建 BVH。
+ * 结果缓存在内存中；多次调用只解析一次。
+ * 文件不存在时返回 null。
+ */
+export function getMapTri(mapName: string): TriangleBvh | null {
+  const cached = triBvhCache.get(mapName);
+  if (cached !== undefined) return cached;
+
+  const triPath = resolveTriPath(mapName);
+  let bytes: Buffer;
+  try {
+    bytes = readFileSync(triPath);
+  } catch {
+    triBvhCache.set(mapName, null);
+    return null;
+  }
+
+  const triangles = parseAwpyTri(bytes);
+  const bvh = buildTriangleBvh(triangles);
+  triBvhCache.set(mapName, bvh);
+  return bvh;
+}
+
+/**
+ * 检查指定地图的 .tri 文件是否可用（不做解析，只看文件是否存在）。
+ */
+export function hasMapTri(mapName: string): boolean {
+  if (triBvhCache.has(mapName)) return triBvhCache.get(mapName) !== null;
+  try {
+    const { statSync } = require("node:fs") as typeof import("node:fs");
+    statSync(resolveTriPath(mapName));
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * 清空 BVH 缓存（测试/重新加载用）。
+ */
+export function clearTriCache(): void {
+  triBvhCache.clear();
+}

package/src/visibility.test.ts

@@ -0,0 +1,36 @@
+import { describe, expect, it } from "vitest";
+import {
+  buildTriangleBvh,
+  parseAwpyTri,
+  staticLineOfSight,
+  type Triangle,
+} from "./visibility.js";
+
+const wall: Triangle = {
+  a: { x: 0, y: -10, z: -10 },
+  b: { x: 0, y: 10, z: -10 },
+  c: { x: 0, y: 0, z: 10 },
+};
+
+describe("static line of sight", () => {
+  it("reads awpy little-endian triangle streams", () => {
+    const values = [-1, -2, -3, 1, 2, 3, 4, 5, 6];
+    const buffer = new ArrayBuffer(values.length * 4);
+    const view = new DataView(buffer);
+    values.forEach((value, index) => view.setFloat32(index * 4, value, true));
+
+    expect(parseAwpyTri(buffer)).toEqual([
+      {
+        a: { x: -1, y: -2, z: -3 },
+        b: { x: 1, y: 2, z: 3 },
+        c: { x: 4, y: 5, z: 6 },
+      },
+    ]);
+  });
+
+  it("reports whether static collision geometry blocks a segment", () => {
+    const bvh = buildTriangleBvh([wall]);
+    expect(staticLineOfSight(bvh, { x: -5, y: 0, z: 0 }, { x: 5, y: 0, z: 0 })).toBe(false);
+    expect(staticLineOfSight(bvh, { x: -5, y: 20, z: 0 }, { x: 5, y: 20, z: 0 })).toBe(true);
+  });
+});