blacktrigram 0.7.2

package/lib/systems/physics/CollisionDetection.js

@@ -0,0 +1,543 @@
+import { ANATOMICAL_DIMENSIONS, BASE_REACH, STANCE_REACH_MODIFIERS } from "../../types/physics.js";
+import { ThreeObjectPools } from "../../utils/threeObjectPool.js";
+import VITAL_POINTS_DATA from "../vitalpoint/VitalPointsData.js";
+import { CoordinateMapper } from "./CoordinateMapper.js";
+import * as THREE from "three";
+//#region src/systems/physics/CollisionDetection.ts
+/**
+* Collision Detection System for Black Trigram combat physics.
+*
+* **Korean**: 충돌 감지 시스템
+*
+* Implements precise collision detection for the 70 vital points combat system using:
+* - Broad-phase AABB (Axis-Aligned Bounding Box) checks for performance
+* - Narrow-phase raycasting for precise vital point detection
+* - Attack reach validation based on technique and stance
+* - Bounding boxes for 5 anatomical regions
+*
+* ## Architecture
+*
+* The system uses a two-phase collision detection approach:
+*
+* 1. **Broad-phase**: Fast AABB checks to eliminate impossible collisions
+* 2. **Narrow-phase**: Precise raycasting to identify specific vital points
+*
+* This ensures 60fps performance even with complex collision queries.
+*
+* ## Performance
+*
+* - Broad-phase: O(1) per check (simple distance comparison)
+* - Narrow-phase: O(n) where n = vital points in region (typically 8-20)
+* - Target: <100 collision checks per frame for 60fps
+*
+* @example
+* ```typescript
+* const collision = new CollisionDetection();
+*
+* const result = collision.checkAttackHit(
+*   { x: 0, y: 0, z: 5 },        // Attacker position
+*   { x: 0, y: 0, z: 6.5 },      // Defender position
+*   { id: "kick", type: "kick" }, // Technique
+*   TrigramStance.LI,             // Attacker stance
+*   "torso"                       // Target region
+* );
+*
+* if (result.hit) {
+*   console.log(`Hit ${result.vitalPoint?.names.english}!`);
+*   console.log(`Accuracy: ${(result.accuracy * 100).toFixed(1)}%`);
+* }
+* ```
+*
+* @module systems/physics/CollisionDetection
+* @category Combat Systems
+* @korean 충돌감지시스템
+*/
+/**
+* Collision Detection Engine for combat physics.
+*
+* **Korean**: 충돌 감지 엔진
+*
+* Provides efficient collision detection for combat using bounding boxes and raycasting.
+* Optimized for 60fps performance with multiple simultaneous collision checks.
+*
+* @public
+* @category Combat Systems
+* @korean 충돌감지엔진
+*/
+var CollisionDetection = class {
+	boundingBoxes = /* @__PURE__ */ new Map();
+	raycaster = new THREE.Raycaster();
+	vitalPointsByRegion = /* @__PURE__ */ new Map();
+	geometryCache = /* @__PURE__ */ new Map();
+	coordinateMapper;
+	/**
+	* Creates a new CollisionDetection instance.
+	*
+	* Initializes bounding boxes for all anatomical regions and organizes
+	* vital points by region for efficient lookup.
+	*/
+	constructor() {
+		this.coordinateMapper = new CoordinateMapper();
+		this.initializeBoundingBoxes();
+		this.organizeVitalPointsByRegion();
+		this.initializeGeometryCache();
+	}
+	/**
+	* Cleans up Three.js resources.
+	*
+	* **Korean**: 자원 정리
+	*
+	* Disposes of cached geometries and releases memory to prevent leaks.
+	* Should be called when the CollisionDetection instance is no longer needed.
+	*
+	* @public
+	* @korean 자원정리
+	*/
+	dispose() {
+		for (const geometry of this.geometryCache.values()) geometry.dispose();
+		this.geometryCache.clear();
+	}
+	/**
+	* Checks if an attack hits the defender.
+	*
+	* **Korean**: 공격 타격 확인
+	*
+	* Performs two-phase collision detection:
+	* 1. Calculate effective attack reach based on technique and stance
+	* 2. Broad-phase: Check if defender is within reach
+	* 3. Broad-phase: Check if target region's AABB is within reach
+	* 4. Narrow-phase: Raycast to find precise vital point hit
+	*
+	* @param attackerPosition - 3D position of the attacker
+	* @param defenderPosition - 3D position of the defender
+	* @param technique - Technique being used with type information
+	* @param attackerStance - Attacker's current trigram stance
+	* @param targetRegion - Anatomical region being targeted
+	* @returns Collision result with hit status, vital point, distance, and accuracy
+	*
+	* @example
+	* ```typescript
+	* const result = collision.checkAttackHit(
+	*   { x: 0, y: 0, z: 5 },
+	*   { x: 0, y: 0, z: 6 },
+	*   { type: "punch" },
+	*   TrigramStance.GEON,
+	*   "head"
+	* );
+	* ```
+	*
+	* @public
+	* @korean 공격타격확인
+	*/
+	checkAttackHit(attackerPosition, defenderPosition, technique, attackerStance, targetRegion) {
+		const techniqueType = this.parseTechniqueType(technique.type);
+		const attackReach = this.calculateAttackReach(techniqueType, attackerStance);
+		const distance = this.calculateDistance3D(attackerPosition, defenderPosition);
+		if (distance > attackReach.effectiveReach) return {
+			hit: false,
+			distance,
+			accuracy: 0
+		};
+		const targetBox = this.boundingBoxes.get(targetRegion);
+		if (!targetBox) return {
+			hit: false,
+			distance,
+			accuracy: 0
+		};
+		const raycastQuery = {
+			origin: attackerPosition,
+			direction: this.normalizeVector3D(this.subtractVectors3D(defenderPosition, attackerPosition)),
+			maxDistance: attackReach.effectiveReach,
+			targetRegion
+		};
+		const intersection = this.raycastBoundingBox(raycastQuery, targetBox, defenderPosition);
+		if (!intersection) return {
+			hit: false,
+			distance,
+			accuracy: 0
+		};
+		const vitalPoint = this.identifyVitalPoint(targetRegion, intersection.point, defenderPosition);
+		if (!vitalPoint) return {
+			hit: false,
+			distance,
+			accuracy: 0
+		};
+		return {
+			hit: true,
+			region: targetRegion,
+			vitalPoint,
+			distance,
+			accuracy: this.calculateHitAccuracy(intersection.point, vitalPoint, defenderPosition),
+			hitPoint: intersection.point
+		};
+	}
+	/**
+	* Calculates effective attack reach for a technique.
+	*
+	* **Korean**: 공격 범위 계산
+	*
+	* Applies stance modifiers to base technique reach.
+	*
+	* @param techniqueType - Type of technique
+	* @param stance - Current trigram stance
+	* @returns Attack reach with all modifiers applied
+	*
+	* @private
+	* @korean 공격범위계산
+	*/
+	calculateAttackReach(techniqueType, stance) {
+		const baseReach = BASE_REACH[techniqueType];
+		const stanceModifier = STANCE_REACH_MODIFIERS[stance];
+		return {
+			technique: techniqueType,
+			baseReach,
+			stance,
+			stanceModifier,
+			effectiveReach: baseReach * stanceModifier
+		};
+	}
+	/**
+	* Performs raycasting against a bounding box.
+	*
+	* **Korean**: 경계 상자 광선 투사
+	*
+	* Uses cached geometries from object pool to avoid repeated allocations
+	* during combat. Creates a Three.js mesh for the bounding box and performs
+	* raycasting to detect intersection points.
+	*
+	* Uses object pooling for Vector3 allocations to reduce GC pressure.
+	*
+	* @param query - Raycast query parameters
+	* @param box - Bounding box to test
+	* @param defenderPosition - Position of the defender
+	* @returns Intersection point or null if no hit
+	*
+	* @private
+	* @korean 경계상자광선투사
+	*/
+	raycastBoundingBox(query, box, defenderPosition) {
+		const cacheKey = `${box.type}-${box.region}`;
+		let geometry = this.geometryCache.get(cacheKey);
+		if (!geometry) {
+			geometry = this.createGeometryForBox(box);
+			this.geometryCache.set(cacheKey, geometry);
+		}
+		const mesh = new THREE.Mesh(geometry);
+		mesh.position.set(defenderPosition.x + box.center.x, defenderPosition.y + box.center.y, defenderPosition.z + box.center.z);
+		const origin = ThreeObjectPools.vector3.acquire();
+		const direction = ThreeObjectPools.vector3.acquire();
+		try {
+			origin.set(query.origin.x, query.origin.y, query.origin.z);
+			direction.set(query.direction.x, query.direction.y, query.direction.z);
+			this.raycaster.set(origin, direction);
+			this.raycaster.far = query.maxDistance;
+			const intersections = this.raycaster.intersectObject(mesh);
+			if (intersections.length > 0) {
+				const point = intersections[0].point;
+				return { point: {
+					x: point.x,
+					y: point.y,
+					z: point.z
+				} };
+			}
+			return null;
+		} finally {
+			ThreeObjectPools.vector3.release(origin);
+			ThreeObjectPools.vector3.release(direction);
+		}
+	}
+	/**
+	* Creates Three.js geometry for a bounding box.
+	*
+	* Helper method for geometry cache initialization.
+	*
+	* @param box - Bounding box specification
+	* @returns Three.js geometry
+	*
+	* @private
+	* @korean 경계상자지오메트리생성
+	*/
+	createGeometryForBox(box) {
+		switch (box.type) {
+			case "sphere": return new THREE.SphereGeometry(box.dimensions.x, 8, 8);
+			case "box": return new THREE.BoxGeometry(box.dimensions.x, box.dimensions.y, box.dimensions.z);
+			case "capsule": return new THREE.CapsuleGeometry(box.dimensions.x, box.dimensions.y, 4, 8);
+		}
+	}
+	/**
+	* Identifies the specific vital point hit within a region.
+	*
+	* **Korean**: 급소 식별
+	*
+	* Finds the closest vital point to the hit location within the targeted region.
+	*
+	* @param region - Anatomical region hit
+	* @param hitPoint - 3D point where attack intersected
+	* @param defenderPosition - Position of the defender
+	* @returns Closest vital point or null if none found
+	*
+	* @private
+	* @korean 급소식별
+	*/
+	identifyVitalPoint(region, hitPoint, _defenderPosition) {
+		const vitalPoints = this.vitalPointsByRegion.get(region);
+		if (!vitalPoints || vitalPoints.length === 0) return null;
+		const result = this.coordinateMapper.findClosestVitalPoint(hitPoint, vitalPoints, region);
+		return result ? result.vitalPoint : vitalPoints.length > 0 ? vitalPoints[0] : null;
+	}
+	/**
+	* Calculates hit accuracy based on distance to vital point center.
+	*
+	* **Korean**: 타격 정확도 계산
+	*
+	* Accuracy decreases linearly with distance from vital point center.
+	* Perfect accuracy (1.0) at center, decreasing to 0 at 5cm radius.
+	*
+	* @param hitPoint - Point where attack landed
+	* @param vitalPoint - Target vital point
+	* @param defenderPosition - Position of the defender
+	* @returns Accuracy value from 0 to 1
+	*
+	* @private
+	* @korean 타격정확도계산
+	*/
+	calculateHitAccuracy(hitPoint, vitalPoint, _defenderPosition) {
+		const distance = this.coordinateMapper.distanceToVitalPoint(hitPoint, vitalPoint);
+		return Math.max(0, 1 - distance / .05);
+	}
+	/**
+	* Calculates Euclidean distance between two 3D points.
+	*
+	* @param pos1 - First position
+	* @param pos2 - Second position
+	* @returns Distance in meters
+	*
+	* @private
+	* @korean 3D거리계산
+	*/
+	calculateDistance3D(pos1, pos2) {
+		const dx = pos1.x - pos2.x;
+		const dy = pos1.y - pos2.y;
+		const dz = pos1.z - pos2.z;
+		return Math.sqrt(dx * dx + dy * dy + dz * dz);
+	}
+	/**
+	* Subtracts one 3D vector from another.
+	*
+	* @param v1 - First vector
+	* @param v2 - Second vector
+	* @returns Resulting vector
+	*
+	* @private
+	* @korean 벡터빼기
+	*/
+	subtractVectors3D(v1, v2) {
+		return {
+			x: v1.x - v2.x,
+			y: v1.y - v2.y,
+			z: v1.z - v2.z
+		};
+	}
+	/**
+	* Normalizes a 3D vector to unit length.
+	*
+	* @param vec - Vector to normalize
+	* @returns Normalized vector
+	*
+	* @private
+	* @korean 벡터정규화
+	*/
+	normalizeVector3D(vec) {
+		const length = Math.sqrt(vec.x * vec.x + vec.y * vec.y + vec.z * vec.z);
+		if (length === 0) return {
+			x: 0,
+			y: 0,
+			z: 1
+		};
+		return {
+			x: vec.x / length,
+			y: vec.y / length,
+			z: vec.z / length
+		};
+	}
+	/**
+	* Parses technique type from string.
+	*
+	* @param techniqueTypeStr - Technique type as string
+	* @returns Parsed technique type
+	*
+	* @private
+	* @korean 기술유형파싱
+	*/
+	parseTechniqueType(techniqueTypeStr) {
+		return {
+			punch: "punch",
+			kick: "kick",
+			elbow: "elbow",
+			knee: "knee",
+			pressure_point: "pressure_point",
+			strike: "punch"
+		}[techniqueTypeStr ?? "punch"] ?? "punch";
+	}
+	/**
+	* Initializes bounding boxes for all anatomical regions.
+	*
+	* Creates collision volumes for the 5 anatomical regions using the
+	* ANATOMICAL_DIMENSIONS constants from the physics types module.
+	*
+	* @private
+	* @korean 경계상자초기화
+	*/
+	initializeBoundingBoxes() {
+		this.boundingBoxes.set("head", {
+			type: ANATOMICAL_DIMENSIONS.head.type,
+			center: ANATOMICAL_DIMENSIONS.head.center,
+			dimensions: {
+				x: ANATOMICAL_DIMENSIONS.head.radius,
+				y: 0,
+				z: 0
+			},
+			region: "head"
+		});
+		this.boundingBoxes.set("neck", {
+			type: ANATOMICAL_DIMENSIONS.neck.type,
+			center: ANATOMICAL_DIMENSIONS.neck.center,
+			dimensions: {
+				x: ANATOMICAL_DIMENSIONS.neck.radius,
+				y: ANATOMICAL_DIMENSIONS.neck.height,
+				z: 0
+			},
+			region: "neck"
+		});
+		this.boundingBoxes.set("torso", {
+			type: ANATOMICAL_DIMENSIONS.torso.type,
+			center: ANATOMICAL_DIMENSIONS.torso.center,
+			dimensions: {
+				x: ANATOMICAL_DIMENSIONS.torso.width,
+				y: ANATOMICAL_DIMENSIONS.torso.height,
+				z: ANATOMICAL_DIMENSIONS.torso.depth
+			},
+			region: "torso"
+		});
+		this.boundingBoxes.set("arms", {
+			type: ANATOMICAL_DIMENSIONS.arms.type,
+			center: ANATOMICAL_DIMENSIONS.arms.center,
+			dimensions: {
+				x: ANATOMICAL_DIMENSIONS.arms.radius,
+				y: ANATOMICAL_DIMENSIONS.arms.height,
+				z: 0
+			},
+			region: "arms"
+		});
+		this.boundingBoxes.set("legs", {
+			type: ANATOMICAL_DIMENSIONS.legs.type,
+			center: ANATOMICAL_DIMENSIONS.legs.center,
+			dimensions: {
+				x: ANATOMICAL_DIMENSIONS.legs.radius,
+				y: ANATOMICAL_DIMENSIONS.legs.height,
+				z: 0
+			},
+			region: "legs"
+		});
+	}
+	/**
+	* Initializes geometry cache for object pooling.
+	*
+	* Pre-creates all geometries needed for raycasting to avoid repeated
+	* allocations during combat. Critical for maintaining 60fps with up to
+	* 100 collision checks per frame.
+	*
+	* @private
+	* @korean 지오메트리캐시초기화
+	*/
+	initializeGeometryCache() {
+		for (const box of this.boundingBoxes.values()) {
+			const cacheKey = `${box.type}-${box.region}`;
+			const geometry = this.createGeometryForBox(box);
+			this.geometryCache.set(cacheKey, geometry);
+		}
+	}
+	/**
+	* Organizes vital points by anatomical region for efficient lookup.
+	*
+	* NOTE: This categorization currently uses y-coordinate thresholds that assume
+	* positions are in meters. However, VITAL_POINTS_DATA uses pixel coordinates
+	* (e.g., y: 50), which will cause incorrect categorization. Most vital points
+	* will end up in the "legs" region since pixel y-coordinates are typically less
+	* than 0.8.
+	*
+	* TODO: After implementing 2D→3D coordinate mapping, update this method to use
+	* the converted 3D positions, or use the anatomical region data that may already
+	* exist in the vital points data structure.
+	*
+	* Categorizes the 70 vital points into their respective regions:
+	* - Head: 10 vital points
+	* - Neck: 8 vital points
+	* - Torso: 20 vital points
+	* - Arms: 16 vital points
+	* - Legs: 16 vital points
+	*
+	* @private
+	* @korean 급소영역별정리
+	*/
+	organizeVitalPointsByRegion() {
+		const regionMap = new Map([
+			["head", []],
+			["neck", []],
+			["torso", []],
+			["arms", []],
+			["legs", []]
+		]);
+		for (const vp of VITAL_POINTS_DATA) {
+			let region;
+			if (vp.id.includes("_neck") || vp.id.includes("_throat") || vp.id === "head_side_neck" || vp.id === "head_throat") region = "neck";
+			else if (vp.id.startsWith("head_")) region = "head";
+			else if (vp.id.startsWith("torso_")) region = "torso";
+			else if (vp.id.startsWith("arm_left_") || vp.id.startsWith("arm_right_")) region = "arms";
+			else if (vp.id.startsWith("leg_left_") || vp.id.startsWith("leg_right_")) region = "legs";
+			else region = "torso";
+			const list = regionMap.get(region);
+			if (list) list.push(vp);
+		}
+		this.vitalPointsByRegion = regionMap;
+	}
+	/**
+	* Gets the bounding box for an anatomical region.
+	*
+	* @param region - Anatomical region
+	* @returns Bounding box or undefined if not found
+	*
+	* @public
+	* @korean 경계상자조회
+	*/
+	getBoundingBox(region) {
+		return this.boundingBoxes.get(region);
+	}
+	/**
+	* Gets all bounding boxes.
+	*
+	* @returns Map of all bounding boxes by region
+	*
+	* @public
+	* @korean 모든경계상자조회
+	*/
+	getAllBoundingBoxes() {
+		return this.boundingBoxes;
+	}
+	/**
+	* Gets vital points for a specific region.
+	*
+	* @param region - Anatomical region
+	* @returns Array of vital points in that region
+	*
+	* @public
+	* @korean 영역별급소조회
+	*/
+	getVitalPointsInRegion(region) {
+		return this.vitalPointsByRegion.get(region) ?? [];
+	}
+};
+//#endregion
+export { CollisionDetection as default };
+
+//# sourceMappingURL=CollisionDetection.js.map

package/lib/systems/physics/CollisionDetection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CollisionDetection.js","names":[],"sources":["../../../src/systems/physics/CollisionDetection.ts"],"sourcesContent":["/**\n * Collision Detection System for Black Trigram combat physics.\n *\n * **Korean**: 충돌 감지 시스템\n *\n * Implements precise collision detection for the 70 vital points combat system using:\n * - Broad-phase AABB (Axis-Aligned Bounding Box) checks for performance\n * - Narrow-phase raycasting for precise vital point detection\n * - Attack reach validation based on technique and stance\n * - Bounding boxes for 5 anatomical regions\n *\n * ## Architecture\n *\n * The system uses a two-phase collision detection approach:\n *\n * 1. **Broad-phase**: Fast AABB checks to eliminate impossible collisions\n * 2. **Narrow-phase**: Precise raycasting to identify specific vital points\n *\n * This ensures 60fps performance even with complex collision queries.\n *\n * ## Performance\n *\n * - Broad-phase: O(1) per check (simple distance comparison)\n * - Narrow-phase: O(n) where n = vital points in region (typically 8-20)\n * - Target: <100 collision checks per frame for 60fps\n *\n * @example\n * ```typescript\n * const collision = new CollisionDetection();\n *\n * const result = collision.checkAttackHit(\n *   { x: 0, y: 0, z: 5 },        // Attacker position\n *   { x: 0, y: 0, z: 6.5 },      // Defender position\n *   { id: \"kick\", type: \"kick\" }, // Technique\n *   TrigramStance.LI,             // Attacker stance\n *   \"torso\"                       // Target region\n * );\n *\n * if (result.hit) {\n *   console.log(`Hit ${result.vitalPoint?.names.english}!`);\n *   console.log(`Accuracy: ${(result.accuracy * 100).toFixed(1)}%`);\n * }\n * ```\n *\n * @module systems/physics/CollisionDetection\n * @category Combat Systems\n * @korean 충돌감지시스템\n */\n\nimport * as THREE from \"three\";\nimport { TrigramStance } from \"../../types/common\";\nimport type {\n  AnatomicalRegionPhysics,\n  BoundingBox,\n  CollisionResult,\n  Position3D,\n  RaycastQuery,\n  TechniqueType,\n} from \"../../types/physics\";\nimport {\n  ANATOMICAL_DIMENSIONS,\n  BASE_REACH,\n  STANCE_REACH_MODIFIERS,\n} from \"../../types/physics\";\nimport type { VitalPoint } from \"../vitalpoint/types\";\nimport { VITAL_POINTS_DATA } from \"../vitalpoint/VitalPointsData\";\nimport { CoordinateMapper } from \"./CoordinateMapper\";\nimport { ThreeObjectPools } from \"../../utils/threeObjectPool\";\n\n/**\n * Collision Detection Engine for combat physics.\n *\n * **Korean**: 충돌 감지 엔진\n *\n * Provides efficient collision detection for combat using bounding boxes and raycasting.\n * Optimized for 60fps performance with multiple simultaneous collision checks.\n *\n * @public\n * @category Combat Systems\n * @korean 충돌감지엔진\n */\nexport class CollisionDetection {\n  private readonly boundingBoxes: Map<AnatomicalRegionPhysics, BoundingBox> =\n    new Map();\n  private readonly raycaster: THREE.Raycaster = new THREE.Raycaster();\n  private vitalPointsByRegion: Map<AnatomicalRegionPhysics, VitalPoint[]> =\n    new Map();\n\n  // Geometry cache for object pooling to avoid repeated allocations during combat\n  private readonly geometryCache: Map<string, THREE.BufferGeometry> = new Map();\n\n  // Coordinate mapper for 2D→3D conversion\n  private readonly coordinateMapper: CoordinateMapper;\n\n  /**\n   * Creates a new CollisionDetection instance.\n   *\n   * Initializes bounding boxes for all anatomical regions and organizes\n   * vital points by region for efficient lookup.\n   */\n  constructor() {\n    this.coordinateMapper = new CoordinateMapper();\n    this.initializeBoundingBoxes();\n    this.organizeVitalPointsByRegion();\n    this.initializeGeometryCache();\n  }\n\n  /**\n   * Cleans up Three.js resources.\n   *\n   * **Korean**: 자원 정리\n   *\n   * Disposes of cached geometries and releases memory to prevent leaks.\n   * Should be called when the CollisionDetection instance is no longer needed.\n   *\n   * @public\n   * @korean 자원정리\n   */\n  public dispose(): void {\n    // Dispose all cached geometries\n    for (const geometry of this.geometryCache.values()) {\n      geometry.dispose();\n    }\n    this.geometryCache.clear();\n  }\n\n  /**\n   * Checks if an attack hits the defender.\n   *\n   * **Korean**: 공격 타격 확인\n   *\n   * Performs two-phase collision detection:\n   * 1. Calculate effective attack reach based on technique and stance\n   * 2. Broad-phase: Check if defender is within reach\n   * 3. Broad-phase: Check if target region's AABB is within reach\n   * 4. Narrow-phase: Raycast to find precise vital point hit\n   *\n   * @param attackerPosition - 3D position of the attacker\n   * @param defenderPosition - 3D position of the defender\n   * @param technique - Technique being used with type information\n   * @param attackerStance - Attacker's current trigram stance\n   * @param targetRegion - Anatomical region being targeted\n   * @returns Collision result with hit status, vital point, distance, and accuracy\n   *\n   * @example\n   * ```typescript\n   * const result = collision.checkAttackHit(\n   *   { x: 0, y: 0, z: 5 },\n   *   { x: 0, y: 0, z: 6 },\n   *   { type: \"punch\" },\n   *   TrigramStance.GEON,\n   *   \"head\"\n   * );\n   * ```\n   *\n   * @public\n   * @korean 공격타격확인\n   */\n  checkAttackHit(\n    attackerPosition: Position3D,\n    defenderPosition: Position3D,\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- Technique object has dynamic properties from combat system\n    technique: { type?: string; [key: string]: any },\n    attackerStance: TrigramStance,\n    targetRegion: AnatomicalRegionPhysics,\n  ): CollisionResult {\n    // Calculate effective attack reach\n    const techniqueType = this.parseTechniqueType(technique.type);\n    const attackReach = this.calculateAttackReach(\n      techniqueType,\n      attackerStance,\n    );\n\n    // Calculate distance between attacker and defender\n    const distance = this.calculateDistance3D(\n      attackerPosition,\n      defenderPosition,\n    );\n\n    // Broad-phase: Check if defender is within reach\n    if (distance > attackReach.effectiveReach) {\n      return {\n        hit: false,\n        distance,\n        accuracy: 0,\n      };\n    }\n\n    // Get target region bounding box\n    const targetBox = this.boundingBoxes.get(targetRegion);\n    if (!targetBox) {\n      return {\n        hit: false,\n        distance,\n        accuracy: 0,\n      };\n    }\n\n    // Narrow-phase: Raycast from attacker to target region\n    const attackDirection = this.normalizeVector3D(\n      this.subtractVectors3D(defenderPosition, attackerPosition),\n    );\n\n    const raycastQuery: RaycastQuery = {\n      origin: attackerPosition,\n      direction: attackDirection,\n      maxDistance: attackReach.effectiveReach,\n      targetRegion,\n    };\n\n    // Check intersection with target bounding box\n    const intersection = this.raycastBoundingBox(\n      raycastQuery,\n      targetBox,\n      defenderPosition,\n    );\n\n    if (!intersection) {\n      return {\n        hit: false,\n        distance,\n        accuracy: 0,\n      };\n    }\n\n    // Determine specific vital point within region\n    const vitalPoint = this.identifyVitalPoint(\n      targetRegion,\n      intersection.point,\n      defenderPosition,\n    );\n\n    if (!vitalPoint) {\n      return {\n        hit: false,\n        distance,\n        accuracy: 0,\n      };\n    }\n\n    // Calculate accuracy (how close to vital point center)\n    const accuracy = this.calculateHitAccuracy(\n      intersection.point,\n      vitalPoint,\n      defenderPosition,\n    );\n\n    return {\n      hit: true,\n      region: targetRegion,\n      vitalPoint,\n      distance,\n      accuracy,\n      hitPoint: intersection.point,\n    };\n  }\n\n  /**\n   * Calculates effective attack reach for a technique.\n   *\n   * **Korean**: 공격 범위 계산\n   *\n   * Applies stance modifiers to base technique reach.\n   *\n   * @param techniqueType - Type of technique\n   * @param stance - Current trigram stance\n   * @returns Attack reach with all modifiers applied\n   *\n   * @private\n   * @korean 공격범위계산\n   */\n  private calculateAttackReach(\n    techniqueType: TechniqueType,\n    stance: TrigramStance,\n  ): {\n    technique: TechniqueType;\n    baseReach: number;\n    stance: TrigramStance;\n    stanceModifier: number;\n    effectiveReach: number;\n  } {\n    // Use BASE_REACH constant from physics types\n    const baseReach = BASE_REACH[techniqueType];\n\n    // Use STANCE_REACH_MODIFIERS constant from physics types\n    const stanceModifier = STANCE_REACH_MODIFIERS[stance];\n    const effectiveReach = baseReach * stanceModifier;\n\n    return {\n      technique: techniqueType,\n      baseReach,\n      stance,\n      stanceModifier,\n      effectiveReach,\n    };\n  }\n\n  /**\n   * Performs raycasting against a bounding box.\n   *\n   * **Korean**: 경계 상자 광선 투사\n   *\n   * Uses cached geometries from object pool to avoid repeated allocations\n   * during combat. Creates a Three.js mesh for the bounding box and performs\n   * raycasting to detect intersection points.\n   *\n   * Uses object pooling for Vector3 allocations to reduce GC pressure.\n   *\n   * @param query - Raycast query parameters\n   * @param box - Bounding box to test\n   * @param defenderPosition - Position of the defender\n   * @returns Intersection point or null if no hit\n   *\n   * @private\n   * @korean 경계상자광선투사\n   */\n  private raycastBoundingBox(\n    query: RaycastQuery,\n    box: BoundingBox,\n    defenderPosition: Position3D,\n  ): { point: Position3D } | null {\n    // Get cached geometry from pool to avoid repeated allocations\n    const cacheKey = `${box.type}-${box.region}`;\n    let geometry = this.geometryCache.get(cacheKey);\n\n    // If not cached (shouldn't happen after initialization), create it\n    if (!geometry) {\n      geometry = this.createGeometryForBox(box);\n      this.geometryCache.set(cacheKey, geometry);\n    }\n\n    // Create temporary mesh for raycasting (mesh is lightweight, geometry is cached)\n    const mesh = new THREE.Mesh(geometry);\n    mesh.position.set(\n      defenderPosition.x + box.center.x,\n      defenderPosition.y + box.center.y,\n      defenderPosition.z + box.center.z,\n    );\n\n    // Setup raycaster using pooled Vector3 objects to reduce GC pressure\n    // Wrap in try-finally to ensure pooled objects are always released\n    const origin = ThreeObjectPools.vector3.acquire();\n    const direction = ThreeObjectPools.vector3.acquire();\n\n    try {\n      origin.set(query.origin.x, query.origin.y, query.origin.z);\n      direction.set(query.direction.x, query.direction.y, query.direction.z);\n\n      this.raycaster.set(origin, direction);\n      this.raycaster.far = query.maxDistance;\n\n      // Perform raycast\n      const intersections = this.raycaster.intersectObject(mesh);\n\n      // Clean up temporary mesh (geometry remains cached)\n      // Note: mesh.material is undefined, no need to dispose\n\n      if (intersections.length > 0) {\n        const point = intersections[0].point;\n        return {\n          point: { x: point.x, y: point.y, z: point.z },\n        };\n      }\n\n      return null;\n    } finally {\n      // Release pooled objects back to pool (guaranteed even if exception occurs)\n      ThreeObjectPools.vector3.release(origin);\n      ThreeObjectPools.vector3.release(direction);\n    }\n  }\n\n  /**\n   * Creates Three.js geometry for a bounding box.\n   *\n   * Helper method for geometry cache initialization.\n   *\n   * @param box - Bounding box specification\n   * @returns Three.js geometry\n   *\n   * @private\n   * @korean 경계상자지오메트리생성\n   */\n  private createGeometryForBox(box: BoundingBox): THREE.BufferGeometry {\n    switch (box.type) {\n      case \"sphere\":\n        return new THREE.SphereGeometry(box.dimensions.x, 8, 8);\n      case \"box\":\n        return new THREE.BoxGeometry(\n          box.dimensions.x,\n          box.dimensions.y,\n          box.dimensions.z,\n        );\n      case \"capsule\":\n        return new THREE.CapsuleGeometry(\n          box.dimensions.x,\n          box.dimensions.y,\n          4,\n          8,\n        );\n    }\n  }\n\n  /**\n   * Identifies the specific vital point hit within a region.\n   *\n   * **Korean**: 급소 식별\n   *\n   * Finds the closest vital point to the hit location within the targeted region.\n   *\n   * @param region - Anatomical region hit\n   * @param hitPoint - 3D point where attack intersected\n   * @param defenderPosition - Position of the defender\n   * @returns Closest vital point or null if none found\n   *\n   * @private\n   * @korean 급소식별\n   */\n  private identifyVitalPoint(\n    region: AnatomicalRegionPhysics,\n    hitPoint: Position3D,\n    _defenderPosition: Position3D, // Prefixed with _ to indicate intentionally unused\n  ): VitalPoint | null {\n    // Get all vital points for this region\n    const vitalPoints = this.vitalPointsByRegion.get(region);\n    if (!vitalPoints || vitalPoints.length === 0) {\n      return null;\n    }\n\n    // Use CoordinateMapper to find the closest vital point in 3D space\n    const result = this.coordinateMapper.findClosestVitalPoint(\n      hitPoint,\n      vitalPoints,\n      region,\n    );\n\n    // For collision detection, we accept any vital point in the region\n    // even if it's not very close, as long as the region was hit\n    // This provides more forgiving collision detection while still\n    // using accurate 3D positioning for scoring/accuracy\n    return result\n      ? result.vitalPoint\n      : vitalPoints.length > 0\n        ? vitalPoints[0]\n        : null;\n  }\n\n  /**\n   * Calculates hit accuracy based on distance to vital point center.\n   *\n   * **Korean**: 타격 정확도 계산\n   *\n   * Accuracy decreases linearly with distance from vital point center.\n   * Perfect accuracy (1.0) at center, decreasing to 0 at 5cm radius.\n   *\n   * @param hitPoint - Point where attack landed\n   * @param vitalPoint - Target vital point\n   * @param defenderPosition - Position of the defender\n   * @returns Accuracy value from 0 to 1\n   *\n   * @private\n   * @korean 타격정확도계산\n   */\n  private calculateHitAccuracy(\n    hitPoint: Position3D,\n    vitalPoint: VitalPoint,\n    _defenderPosition: Position3D, // Prefixed with _ to indicate intentionally unused\n  ): number {\n    // Use CoordinateMapper to convert vital point to 3D and calculate distance\n    const distance = this.coordinateMapper.distanceToVitalPoint(\n      hitPoint,\n      vitalPoint,\n    );\n\n    // Accuracy calculation: Perfect (1.0) at center, decreasing to 0 at 5cm radius\n    const maxDistance = 0.05; // 5cm radius for vital points\n    const accuracy = Math.max(0, 1 - distance / maxDistance);\n\n    return accuracy;\n  }\n\n  /**\n   * Calculates Euclidean distance between two 3D points.\n   *\n   * @param pos1 - First position\n   * @param pos2 - Second position\n   * @returns Distance in meters\n   *\n   * @private\n   * @korean 3D거리계산\n   */\n  private calculateDistance3D(pos1: Position3D, pos2: Position3D): number {\n    const dx = pos1.x - pos2.x;\n    const dy = pos1.y - pos2.y;\n    const dz = pos1.z - pos2.z;\n    return Math.sqrt(dx * dx + dy * dy + dz * dz);\n  }\n\n  /**\n   * Subtracts one 3D vector from another.\n   *\n   * @param v1 - First vector\n   * @param v2 - Second vector\n   * @returns Resulting vector\n   *\n   * @private\n   * @korean 벡터빼기\n   */\n  private subtractVectors3D(v1: Position3D, v2: Position3D): Position3D {\n    return {\n      x: v1.x - v2.x,\n      y: v1.y - v2.y,\n      z: v1.z - v2.z,\n    };\n  }\n\n  /**\n   * Normalizes a 3D vector to unit length.\n   *\n   * @param vec - Vector to normalize\n   * @returns Normalized vector\n   *\n   * @private\n   * @korean 벡터정규화\n   */\n  private normalizeVector3D(vec: Position3D): Position3D {\n    const length = Math.sqrt(vec.x * vec.x + vec.y * vec.y + vec.z * vec.z);\n    if (length === 0) {\n      return { x: 0, y: 0, z: 1 }; // Default forward direction\n    }\n    return {\n      x: vec.x / length,\n      y: vec.y / length,\n      z: vec.z / length,\n    };\n  }\n\n  /**\n   * Parses technique type from string.\n   *\n   * @param techniqueTypeStr - Technique type as string\n   * @returns Parsed technique type\n   *\n   * @private\n   * @korean 기술유형파싱\n   */\n  private parseTechniqueType(techniqueTypeStr?: string): TechniqueType {\n    const typeMap: Record<string, TechniqueType> = {\n      punch: \"punch\",\n      kick: \"kick\",\n      elbow: \"elbow\",\n      knee: \"knee\",\n      pressure_point: \"pressure_point\",\n      strike: \"punch\", // Default strike to punch\n    };\n\n    return typeMap[techniqueTypeStr ?? \"punch\"] ?? \"punch\";\n  }\n\n  /**\n   * Initializes bounding boxes for all anatomical regions.\n   *\n   * Creates collision volumes for the 5 anatomical regions using the\n   * ANATOMICAL_DIMENSIONS constants from the physics types module.\n   *\n   * @private\n   * @korean 경계상자초기화\n   */\n  private initializeBoundingBoxes(): void {\n    // Head: Sphere (from ANATOMICAL_DIMENSIONS)\n    this.boundingBoxes.set(\"head\", {\n      type: ANATOMICAL_DIMENSIONS.head.type,\n      center: ANATOMICAL_DIMENSIONS.head.center,\n      dimensions: {\n        x: ANATOMICAL_DIMENSIONS.head.radius,\n        y: 0,\n        z: 0,\n      }, // radius only\n      region: \"head\",\n    });\n\n    // Neck: Capsule (from ANATOMICAL_DIMENSIONS)\n    this.boundingBoxes.set(\"neck\", {\n      type: ANATOMICAL_DIMENSIONS.neck.type,\n      center: ANATOMICAL_DIMENSIONS.neck.center,\n      dimensions: {\n        x: ANATOMICAL_DIMENSIONS.neck.radius,\n        y: ANATOMICAL_DIMENSIONS.neck.height,\n        z: 0,\n      }, // radius and height\n      region: \"neck\",\n    });\n\n    // Torso: Box (from ANATOMICAL_DIMENSIONS)\n    this.boundingBoxes.set(\"torso\", {\n      type: ANATOMICAL_DIMENSIONS.torso.type,\n      center: ANATOMICAL_DIMENSIONS.torso.center,\n      dimensions: {\n        x: ANATOMICAL_DIMENSIONS.torso.width,\n        y: ANATOMICAL_DIMENSIONS.torso.height,\n        z: ANATOMICAL_DIMENSIONS.torso.depth,\n      }, // width, height, depth\n      region: \"torso\",\n    });\n\n    // Arms: Capsules (from ANATOMICAL_DIMENSIONS)\n    this.boundingBoxes.set(\"arms\", {\n      type: ANATOMICAL_DIMENSIONS.arms.type,\n      center: ANATOMICAL_DIMENSIONS.arms.center,\n      dimensions: {\n        x: ANATOMICAL_DIMENSIONS.arms.radius,\n        y: ANATOMICAL_DIMENSIONS.arms.height,\n        z: 0,\n      }, // radius and length\n      region: \"arms\",\n    });\n\n    // Legs: Capsules (from ANATOMICAL_DIMENSIONS)\n    this.boundingBoxes.set(\"legs\", {\n      type: ANATOMICAL_DIMENSIONS.legs.type,\n      center: ANATOMICAL_DIMENSIONS.legs.center,\n      dimensions: {\n        x: ANATOMICAL_DIMENSIONS.legs.radius,\n        y: ANATOMICAL_DIMENSIONS.legs.height,\n        z: 0,\n      }, // radius and length\n      region: \"legs\",\n    });\n  }\n\n  /**\n   * Initializes geometry cache for object pooling.\n   *\n   * Pre-creates all geometries needed for raycasting to avoid repeated\n   * allocations during combat. Critical for maintaining 60fps with up to\n   * 100 collision checks per frame.\n   *\n   * @private\n   * @korean 지오메트리캐시초기화\n   */\n  private initializeGeometryCache(): void {\n    // Pre-create and cache geometries for all bounding boxes\n    for (const box of this.boundingBoxes.values()) {\n      const cacheKey = `${box.type}-${box.region}`;\n      const geometry = this.createGeometryForBox(box);\n      this.geometryCache.set(cacheKey, geometry);\n    }\n  }\n\n  /**\n   * Organizes vital points by anatomical region for efficient lookup.\n   *\n   * NOTE: This categorization currently uses y-coordinate thresholds that assume\n   * positions are in meters. However, VITAL_POINTS_DATA uses pixel coordinates\n   * (e.g., y: 50), which will cause incorrect categorization. Most vital points\n   * will end up in the \"legs\" region since pixel y-coordinates are typically less\n   * than 0.8.\n   *\n   * TODO: After implementing 2D→3D coordinate mapping, update this method to use\n   * the converted 3D positions, or use the anatomical region data that may already\n   * exist in the vital points data structure.\n   *\n   * Categorizes the 70 vital points into their respective regions:\n   * - Head: 10 vital points\n   * - Neck: 8 vital points\n   * - Torso: 20 vital points\n   * - Arms: 16 vital points\n   * - Legs: 16 vital points\n   *\n   * @private\n   * @korean 급소영역별정리\n   */\n  private organizeVitalPointsByRegion(): void {\n    const regionMap: Map<AnatomicalRegionPhysics, VitalPoint[]> = new Map([\n      [\"head\", []],\n      [\"neck\", []],\n      [\"torso\", []],\n      [\"arms\", []],\n      [\"legs\", []],\n    ]);\n\n    // Use existing VitalPointsData categorization by ID prefix\n    // This is more reliable than coordinate-based heuristics\n    for (const vp of VITAL_POINTS_DATA) {\n      let region: AnatomicalRegionPhysics;\n\n      // Categorize by ID prefix (existing VitalPointsData convention)\n      // Check neck-related patterns first (more specific) before head (broader)\n      if (\n        vp.id.includes(\"_neck\") ||\n        vp.id.includes(\"_throat\") ||\n        vp.id === \"head_side_neck\" ||\n        vp.id === \"head_throat\"\n      ) {\n        region = \"neck\";\n      } else if (vp.id.startsWith(\"head_\")) {\n        region = \"head\";\n      } else if (vp.id.startsWith(\"torso_\")) {\n        region = \"torso\";\n      } else if (\n        vp.id.startsWith(\"arm_left_\") ||\n        vp.id.startsWith(\"arm_right_\")\n      ) {\n        region = \"arms\";\n      } else if (\n        vp.id.startsWith(\"leg_left_\") ||\n        vp.id.startsWith(\"leg_right_\")\n      ) {\n        region = \"legs\";\n      } else {\n        // Default to torso for uncategorized points (core region)\n        region = \"torso\";\n      }\n\n      const list = regionMap.get(region);\n      if (list) {\n        list.push(vp);\n      }\n    }\n\n    this.vitalPointsByRegion = regionMap;\n  }\n\n  /**\n   * Gets the bounding box for an anatomical region.\n   *\n   * @param region - Anatomical region\n   * @returns Bounding box or undefined if not found\n   *\n   * @public\n   * @korean 경계상자조회\n   */\n  getBoundingBox(region: AnatomicalRegionPhysics): BoundingBox | undefined {\n    return this.boundingBoxes.get(region);\n  }\n\n  /**\n   * Gets all bounding boxes.\n   *\n   * @returns Map of all bounding boxes by region\n   *\n   * @public\n   * @korean 모든경계상자조회\n   */\n  getAllBoundingBoxes(): ReadonlyMap<AnatomicalRegionPhysics, BoundingBox> {\n    return this.boundingBoxes;\n  }\n\n  /**\n   * Gets vital points for a specific region.\n   *\n   * @param region - Anatomical region\n   * @returns Array of vital points in that region\n   *\n   * @public\n   * @korean 영역별급소조회\n   */\n  getVitalPointsInRegion(\n    region: AnatomicalRegionPhysics,\n  ): readonly VitalPoint[] {\n    return this.vitalPointsByRegion.get(region) ?? [];\n  }\n}\n\nexport default CollisionDetection;\n"],"mappings":"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"}