@cs2dak/maps 0.2.0 → 1.0.0

package/src/visibility.ts

@@ -0,0 +1,237 @@
+import type { Vec3 } from "./nav.js";
+
+export type { Vec3 } from "./nav.js";
+
+export interface Triangle {
+  a: Vec3;
+  b: Vec3;
+  c: Vec3;
+}
+
+interface Bounds {
+  min: Vec3;
+  max: Vec3;
+}
+
+export interface TriangleBvh {
+  bounds: Bounds;
+  left?: TriangleBvh;
+  right?: TriangleBvh;
+  triangles?: Triangle[];
+}
+
+const TRIANGLE_BYTES = 9 * Float32Array.BYTES_PER_ELEMENT;
+const LEAF_SIZE = 16;
+const EPSILON = 1e-7;
+
+export function parseAwpyTri(input: ArrayBuffer | Uint8Array): Triangle[] {
+  const bytes = input instanceof Uint8Array ? input : new Uint8Array(input);
+  if (bytes.byteLength % TRIANGLE_BYTES !== 0) {
+    throw new Error(`Invalid awpy triangle stream: ${bytes.byteLength} bytes`);
+  }
+
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const triangles: Triangle[] = [];
+  for (let offset = 0; offset < bytes.byteLength; offset += TRIANGLE_BYTES) {
+    const point = (base: number): Vec3 => ({
+      x: view.getFloat32(offset + base, true),
+      y: view.getFloat32(offset + base + 4, true),
+      z: view.getFloat32(offset + base + 8, true),
+    });
+    triangles.push({ a: point(0), b: point(12), c: point(24) });
+  }
+  return triangles;
+}
+
+/** 三角形 + 预计算质心；建树时避免在 sort 比较器里反复算质心并分配 Vec3。 */
+interface CentroidTriangle {
+  tri: Triangle;
+  c: Vec3;
+}
+
+export function buildTriangleBvh(triangles: Triangle[]): TriangleBvh {
+  if (triangles.length === 0) throw new Error("Cannot build a BVH without triangles");
+  // 质心只算一次（旧实现在每层 sort 比较器里重算并 new Vec3，百万三角形下产生
+  // 数千万次冗余计算与分配）。建树拓扑、分裂点与叶子内容完全不变。
+  const items = triangles.map((tri) => ({ tri, c: triangleCentroid(tri) }));
+  return buildNode(items);
+}
+
+export function staticLineOfSight(root: TriangleBvh, start: Vec3, end: Vec3): boolean {
+  return !segmentHitsNode(root, start, end);
+}
+
+function buildNode(items: CentroidTriangle[]): TriangleBvh {
+  const bounds = boundsForCentroidTriangles(items);
+  if (items.length <= LEAF_SIZE) return { bounds, triangles: items.map((item) => item.tri) };
+
+  const axis = largestAxis(bounds);
+  // 只需把中位数选到 middle 处（左半 ≤、右半 ≥），无需整层全排序：
+  // quickselect 让建树从 O(n log²n) 降到 O(n log n)。LOS 与树结构无关
+  // （每个节点按实际三角形重算 bounds，叶子全量求交），任何合法划分结果都等价。
+  const middle = items.length >> 1;
+  nthElement(items, middle, axis);
+  return {
+    bounds,
+    left: buildNode(items.slice(0, middle)),
+    right: buildNode(items.slice(middle)),
+  };
+}
+
+/** Hoare 划分的 quickselect：原地重排，使 arr[k] 落在按 axis 排序后的位置。 */
+function nthElement(arr: CentroidTriangle[], k: number, axis: keyof Vec3): void {
+  let lo = 0;
+  let hi = arr.length - 1;
+  while (lo < hi) {
+    const pivot = arr[(lo + hi) >> 1].c[axis];
+    let i = lo;
+    let j = hi;
+    while (i <= j) {
+      while (arr[i].c[axis] < pivot) i++;
+      while (arr[j].c[axis] > pivot) j--;
+      if (i <= j) {
+        const tmp = arr[i];
+        arr[i] = arr[j];
+        arr[j] = tmp;
+        i++;
+        j--;
+      }
+    }
+    if (k <= j) hi = j;
+    else if (k >= i) lo = i;
+    else break;
+  }
+}
+
+function boundsForCentroidTriangles(items: CentroidTriangle[]): Bounds {
+  const bounds: Bounds = {
+    min: { x: Number.POSITIVE_INFINITY, y: Number.POSITIVE_INFINITY, z: Number.POSITIVE_INFINITY },
+    max: { x: Number.NEGATIVE_INFINITY, y: Number.NEGATIVE_INFINITY, z: Number.NEGATIVE_INFINITY },
+  };
+  for (const { tri } of items) {
+    for (const point of [tri.a, tri.b, tri.c]) {
+      bounds.min.x = Math.min(bounds.min.x, point.x);
+      bounds.min.y = Math.min(bounds.min.y, point.y);
+      bounds.min.z = Math.min(bounds.min.z, point.z);
+      bounds.max.x = Math.max(bounds.max.x, point.x);
+      bounds.max.y = Math.max(bounds.max.y, point.y);
+      bounds.max.z = Math.max(bounds.max.z, point.z);
+    }
+  }
+  return bounds;
+}
+
+function segmentHitsNode(node: TriangleBvh, start: Vec3, end: Vec3): boolean {
+  if (!segmentHitsBounds(start, end, node.bounds)) return false;
+  if (node.triangles) {
+    for (const triangle of node.triangles) {
+      if (segmentHitsTriangle(start, end, triangle)) return true;
+    }
+    return false;
+  }
+  return (
+    (node.left !== undefined && segmentHitsNode(node.left, start, end)) ||
+    (node.right !== undefined && segmentHitsNode(node.right, start, end))
+  );
+}
+
+function segmentHitsBounds(start: Vec3, end: Vec3, bounds: Bounds): boolean {
+  let minT = 0;
+  let maxT = 1;
+  const sx = start.x, sy = start.y, sz = start.z;
+  const dx = end.x - sx, dy = end.y - sy, dz = end.z - sz;
+  if (Math.abs(dx) < EPSILON) {
+    if (sx < bounds.min.x || sx > bounds.max.x) return false;
+  } else {
+    const inv = 1 / dx;
+    let first = (bounds.min.x - sx) * inv;
+    let second = (bounds.max.x - sx) * inv;
+    if (first > second) {
+      const tmp = first;
+      first = second;
+      second = tmp;
+    }
+    minT = Math.max(minT, first);
+    maxT = Math.min(maxT, second);
+    if (minT > maxT) return false;
+  }
+  if (Math.abs(dy) < EPSILON) {
+    if (sy < bounds.min.y || sy > bounds.max.y) return false;
+  } else {
+    const inv = 1 / dy;
+    let first = (bounds.min.y - sy) * inv;
+    let second = (bounds.max.y - sy) * inv;
+    if (first > second) {
+      const tmp = first;
+      first = second;
+      second = tmp;
+    }
+    minT = Math.max(minT, first);
+    maxT = Math.min(maxT, second);
+    if (minT > maxT) return false;
+  }
+  if (Math.abs(dz) < EPSILON) {
+    if (sz < bounds.min.z || sz > bounds.max.z) return false;
+  } else {
+    const inv = 1 / dz;
+    let first = (bounds.min.z - sz) * inv;
+    let second = (bounds.max.z - sz) * inv;
+    if (first > second) {
+      const tmp = first;
+      first = second;
+      second = tmp;
+    }
+    minT = Math.max(minT, first);
+    maxT = Math.min(maxT, second);
+    if (minT > maxT) return false;
+  }
+  return true;
+}
+
+function segmentHitsTriangle(start: Vec3, end: Vec3, triangle: Triangle): boolean {
+  const dirX = end.x - start.x, dirY = end.y - start.y, dirZ = end.z - start.z;
+  const edge1X = triangle.b.x - triangle.a.x;
+  const edge1Y = triangle.b.y - triangle.a.y;
+  const edge1Z = triangle.b.z - triangle.a.z;
+  const edge2X = triangle.c.x - triangle.a.x;
+  const edge2Y = triangle.c.y - triangle.a.y;
+  const edge2Z = triangle.c.z - triangle.a.z;
+  const hX = dirY * edge2Z - dirZ * edge2Y;
+  const hY = dirZ * edge2X - dirX * edge2Z;
+  const hZ = dirX * edge2Y - dirY * edge2X;
+  const determinant = edge1X * hX + edge1Y * hY + edge1Z * hZ;
+  if (Math.abs(determinant) < EPSILON) return false;
+
+  const inverse = 1 / determinant;
+  const sX = start.x - triangle.a.x;
+  const sY = start.y - triangle.a.y;
+  const sZ = start.z - triangle.a.z;
+  const u = inverse * (sX * hX + sY * hY + sZ * hZ);
+  if (u < 0 || u > 1) return false;
+
+  const qX = sY * edge1Z - sZ * edge1Y;
+  const qY = sZ * edge1X - sX * edge1Z;
+  const qZ = sX * edge1Y - sY * edge1X;
+  const v = inverse * (dirX * qX + dirY * qY + dirZ * qZ);
+  if (v < 0 || u + v > 1) return false;
+
+  const t = inverse * (edge2X * qX + edge2Y * qY + edge2Z * qZ);
+  return t > EPSILON && t < 1 - EPSILON;
+}
+
+function largestAxis(bounds: Bounds): keyof Vec3 {
+  const extents = {
+    x: bounds.max.x - bounds.min.x,
+    y: bounds.max.y - bounds.min.y,
+    z: bounds.max.z - bounds.min.z,
+  };
+  return extents.x >= extents.y && extents.x >= extents.z ? "x" : extents.y >= extents.z ? "y" : "z";
+}
+
+function triangleCentroid(triangle: Triangle): Vec3 {
+  return {
+    x: (triangle.a.x + triangle.b.x + triangle.c.x) / 3,
+    y: (triangle.a.y + triangle.b.y + triangle.c.y) / 3,
+    z: (triangle.a.z + triangle.b.z + triangle.c.z) / 3,
+  };
+}

package/src/zone-assets.ts

@@ -0,0 +1,23 @@
+import ancientZones from "../map-zones/de_ancient.json" with { type: "json" };
+import dust2Zones from "../map-zones/de_dust2.json" with { type: "json" };
+import infernoZones from "../map-zones/de_inferno.json" with { type: "json" };
+import mirageZones from "../map-zones/de_mirage.json" with { type: "json" };
+// legacy zone 资产：不是当前控图/战术语义真相源；控图优先用 callout grid。
+// 其余 3 图不再主动补 zone，除非旧 shadow spatial 路径明确需要。
+// import anubisZones from "../map-zones/de_anubis.json" with { type: "json" };
+// import nukeZones from "../map-zones/de_nuke.json" with { type: "json" };
+// import overpassZones from "../map-zones/de_overpass.json" with { type: "json" };
+import type { MapZones } from "./zones.js";
+import type { ActiveDutyMap } from "./zones.js";
+
+/** legacy 手标 zone 多边形。未标定的图 getMapZones 返回 null。 */
+export const MAP_ZONE_ASSETS: Partial<Record<ActiveDutyMap, MapZones>> = {
+  de_ancient: ancientZones as unknown as MapZones,
+  de_dust2: dust2Zones as unknown as MapZones,
+  de_inferno: infernoZones as unknown as MapZones,
+  de_mirage: mirageZones as unknown as MapZones,
+};
+
+export function getMapZones(mapName: string): MapZones | null {
+  return (MAP_ZONE_ASSETS as Record<string, MapZones | undefined>)[mapName] ?? null;
+}

package/src/zones.ts

@@ -1,14 +1,14 @@
 /**
- * map-zones — 地图区域语义层（P4 空间分析的基础）
+ * map-zones — legacy 手标多边形辅助层
  *
- * 定位：把世界坐标的一个点映射到一个**有名字、有角色**的区域（A 点 / mid / banana …），
- * 供 Area（区域占有）、Utility Block（道具封锁）等空间指标使用。
+ * 当前控图/战术语义真相源不是这里，而是 replay place 生成的 callout grid。
+ * 本文件只保留给旧的 shadow spatial/utility 路径做几何辅助，新增控图判定不要用 zone 当语义来源。
  *
- * 坐标系：多边形顶点用**世界坐标 XY**（与 positions-1s / replay 的 position 同系），
+ * 坐标系：多边形顶点用**世界坐标 XY**（与 v3 replay 的 position 同系），
  * 分辨率无关、无需 radar 标定。多层地图（nuke / vertigo）用可选 [zMin, zMax] 区分上下层。
  *
- * 边界：本文件只做「点 → 区域」的几何归属，不算任何指标，不依赖 demo 数据。
- * 真实多边形坐标由人工在 `map-zones/<map>.json` 标定（这是唯一需要人工的一步）。
+ * 边界：本文件只做「点 → 手标多边形」的几何归属，不算任何指标，不依赖 demo 数据。
+ * 这些多边形不是当前地图理解的真相源。
  */
 
 /** 区域角色：决定该区域在分析里的语义分类（不限定地图）。 */
@@ -78,7 +78,7 @@ export function zoneAt(zones: MapZones, x: number, y: number, z?: number): MapZo
   return null;
 }
 
-/** 当前 CS2 现役图池（train 已移除）。zone 标定与 P4 分析的优先地图。 */
+/** 当前 CS2 现役图池（train 已移除）。保留给 legacy zone 资产枚举。 */
 export const ACTIVE_DUTY_MAPS = [
   "de_ancient",
   "de_anubis",