blacktrigram 0.7.2

package/lib/systems/combat/LimbExposureSystem.js

@@ -0,0 +1,308 @@
+import BREAKING_STATUS_EFFECT_IDS from "./BreakingStatusEffects.js";
+//#region src/systems/combat/LimbExposureSystem.ts
+/**
+* Breaking technique constants
+* **Korean**: 파쇄기술 상수
+*/
+/**
+* Minimum effective force required to successfully execute a breaking technique.
+* Force below this threshold will not break joints/bones.
+* Typical damage values range from 20-80, with 40 being the minimum for effective breaks.
+* @korean 파쇄최소힘
+*/
+var BREAKING_FORCE_THRESHOLD = 40;
+/**
+* Maximum effective force for calculating break severity on 0-1 scale.
+* Force values above 80 are clamped to 1.0 severity (complete break).
+* @korean 파쇄최대힘
+*/
+var BREAKING_MAX_FORCE = 80;
+/**
+* Maximum range in meters for executing counter-attacks.
+* Counter-attacks are close-range defensive techniques requiring proximity.
+* @korean 반격최대거리
+*/
+var MAX_COUNTER_RANGE_METERS = 1;
+/**
+* Calculate counter-attack opportunities from a technique's reach configuration.
+*
+* **Korean**: 반격 기회 계산
+*
+* Analyzes the technique's execution timeline and limb exposure to identify
+* windows where the opponent is vulnerable to counter-attacks.
+*
+* @param technique - The technique being executed
+* @param currentTime - Current time in technique execution (ms)
+* @returns Counter opportunity if one exists, undefined otherwise
+*
+* @public
+* @korean 반격기회계산
+*/
+function calculateCounterOpportunity(technique, currentTime) {
+	const { reachConfig, executionTime } = technique;
+	if (!reachConfig.exposureWindow) return;
+	const exposure = reachConfig.exposureWindow;
+	const windowStart = executionTime * exposure.startTime;
+	const windowEnd = windowStart + exposure.duration;
+	if (currentTime < windowStart || currentTime > windowEnd) return;
+	const recommendedCounters = getRecommendedCounters(exposure.exposedLimb, reachConfig, exposure.allowsBreaking);
+	return {
+		exposedLimb: exposure.exposedLimb,
+		windowStart,
+		windowDuration: exposure.duration,
+		vulnerabilityMultiplier: exposure.vulnerabilityMultiplier,
+		allowsBreaking: exposure.allowsBreaking,
+		recommendedCounters
+	};
+}
+/**
+* Get recommended counter-technique IDs for an exposed limb.
+*
+* **Korean**: 추천 반격 기술 조회
+*
+* Returns technique IDs that would be effective against the exposed limb.
+* These IDs are string-based and should match techniques in the game's
+* technique library. When implementing, validate these IDs exist.
+*
+* **Note**: These are example/placeholder IDs. Actual implementation should
+* reference real technique definitions or use a typed enum of technique IDs.
+*
+* @param exposedLimb - The limb that is exposed
+* @param reachConfig - Reach configuration of the attacking technique
+* @param allowsBreaking - Whether breaking techniques are viable
+* @returns Array of recommended counter-technique IDs (unvalidated strings)
+*
+* @internal
+* @korean 추천반격기술조회
+*/
+function getRecommendedCounters(exposedLimb, reachConfig, allowsBreaking) {
+	const counters = [];
+	if (allowsBreaking) {
+		if (exposedLimb.includes("leg") || exposedLimb.includes("ankle")) counters.push("leg_sweep", "ankle_break", "knee_stomp");
+		else if (exposedLimb.includes("knee")) counters.push("knee_break", "hyperextension_kick");
+		else if (exposedLimb.includes("arm") || exposedLimb.includes("elbow")) counters.push("arm_bar", "elbow_break", "joint_lock");
+		else if (exposedLimb.includes("wrist")) counters.push("wrist_lock", "wrist_break");
+	}
+	if (exposedLimb.includes("arm")) counters.push("ulnar_nerve_strike", "radial_nerve_pressure");
+	else if (exposedLimb.includes("leg")) counters.push("peroneal_nerve_strike", "thigh_pressure_point");
+	if (reachConfig.bodyPart === "leg") counters.push("leg_parry_counter", "inside_leg_kick");
+	else if (reachConfig.bodyPart === "arm") counters.push("arm_trap_counter", "redirect_punch");
+	return counters;
+}
+/**
+* Calculate vulnerability multiplier for a technique at a specific time.
+*
+* **Korean**: 취약성 배수 계산
+*
+* Determines how vulnerable the attacker is at a given point in their
+* technique execution. Useful for damage calculation during counter-attacks.
+*
+* @param technique - The technique being executed
+* @param currentTime - Current time in technique execution (ms)
+* @returns Vulnerability multiplier (1.0 = normal, >1.0 = more vulnerable)
+*
+* @public
+* @korean 취약성배수계산
+*/
+function calculateVulnerabilityMultiplier(technique, currentTime) {
+	const { reachConfig, executionTime, recoveryTime } = technique;
+	if (!reachConfig.exposureWindow) return 1;
+	const exposure = reachConfig.exposureWindow;
+	const windowStart = executionTime * exposure.startTime;
+	const windowEnd = windowStart + exposure.duration;
+	if (currentTime < windowStart) return 1.1;
+	if (currentTime <= windowEnd) return exposure.vulnerabilityMultiplier;
+	const recoveryStart = executionTime;
+	const recoveryEnd = executionTime + recoveryTime;
+	if (currentTime > recoveryStart && currentTime <= recoveryEnd) {
+		const recoveryProgress = (currentTime - recoveryStart) / recoveryTime;
+		return exposure.vulnerabilityMultiplier - (exposure.vulnerabilityMultiplier - 1) * recoveryProgress;
+	}
+	return 1;
+}
+/**
+* Determine which limb is exposed based on technique and animation state.
+*
+* **Korean**: 노출된 사지 결정
+*
+* Analyzes the technique's body part and animation to determine which
+* specific limb (left/right) is currently exposed.
+*
+* @param technique - The technique being executed
+* @param isLeftSided - Whether the technique uses the left side
+* @returns The exposed limb type
+*
+* @public
+* @korean 노출사지결정
+*/
+function determineExposedLimb(technique, isLeftSided = false) {
+	const { reachConfig } = technique;
+	if (reachConfig.exposureWindow?.exposedLimb) return reachConfig.exposureWindow.exposedLimb;
+	const side = isLeftSided ? "left" : "right";
+	switch (reachConfig.bodyPart) {
+		case "arm": if (reachConfig.baseExtension > .8) return `${side}_arm`;
+		else if (reachConfig.baseExtension > .5) return `${side}_elbow`;
+		else return `${side}_wrist`;
+		case "leg": if (reachConfig.baseExtension > 1) return `${side}_leg`;
+		else if (reachConfig.baseExtension > .7) return `${side}_knee`;
+		else return `${side}_ankle`;
+		case "torso": return `${side}_arm`;
+		default: return "right_arm";
+	}
+}
+/**
+* Map exposed limb to breaking technique target.
+*
+* **Korean**: 노출 사지를 파쇄 목표로 매핑
+*
+* Converts an exposed limb type to the appropriate breaking target
+* for joint and limb breaking techniques.
+*
+* @param exposedLimb - The exposed limb
+* @returns The breaking target joint/bone
+*
+* @public
+* @korean 파쇄목표매핑
+*/
+function mapLimbToBreakingTarget(exposedLimb) {
+	if (exposedLimb.includes("ankle")) return "ankle";
+	if (exposedLimb.includes("knee")) return "knee";
+	if (exposedLimb.includes("elbow")) return "elbow";
+	if (exposedLimb.includes("wrist")) return "wrist";
+	if (exposedLimb.includes("leg")) return "knee";
+	if (exposedLimb.includes("arm")) return "elbow";
+	return "elbow";
+}
+/**
+* Calculate breaking technique effectiveness.
+*
+* **Korean**: 파쇄 기술 효과 계산
+*
+* Determines the result of a breaking technique applied to an exposed limb,
+* considering the vulnerability window, force applied, and target joint.
+*
+* @param breakingTechnique - The breaking technique being applied (reserved for future use)
+* @param counterOpportunity - The counter opportunity being exploited
+* @param force - Force/damage of the breaking technique (typically 20-80 range)
+* @returns Result of the breaking attempt
+*
+* @remarks
+* The breakingTechnique parameter is currently unused but reserved for future
+* extensibility. It may be used to apply technique-specific modifiers or
+* validate technique compatibility with the breaking target.
+*
+* @public
+* @korean 파쇄기술효과계산
+*/
+function calculateBreakingResult(breakingTechnique, counterOpportunity, force) {
+	const target = mapLimbToBreakingTarget(counterOpportunity.exposedLimb);
+	if (!counterOpportunity.allowsBreaking) return {
+		success: false,
+		target,
+		severity: 0,
+		damage: force * .5,
+		mobilityReduction: 0,
+		statusEffects: []
+	};
+	const effectiveForce = force * counterOpportunity.vulnerabilityMultiplier;
+	const baseSuccess = effectiveForce > BREAKING_FORCE_THRESHOLD;
+	const severity = Math.min(effectiveForce / BREAKING_MAX_FORCE, 1);
+	if (!baseSuccess) return {
+		success: false,
+		target,
+		severity: 0,
+		damage: effectiveForce * .7,
+		mobilityReduction: 0,
+		statusEffects: []
+	};
+	const statusEffects = [BREAKING_STATUS_EFFECT_IDS.PAIN];
+	let mobilityReduction;
+	if (severity > .8) {
+		statusEffects.push(BREAKING_STATUS_EFFECT_IDS.SEVERE_INJURY, BREAKING_STATUS_EFFECT_IDS.DISABLED_LIMB);
+		mobilityReduction = .6;
+		if (target === "ankle" || target === "knee") {
+			statusEffects.push(BREAKING_STATUS_EFFECT_IDS.IMPAIRED_MOBILITY);
+			mobilityReduction = .8;
+		}
+	} else if (severity > .5) {
+		statusEffects.push(BREAKING_STATUS_EFFECT_IDS.INJURED_LIMB);
+		mobilityReduction = .4;
+	} else {
+		statusEffects.push(BREAKING_STATUS_EFFECT_IDS.SPRAINED_JOINT);
+		mobilityReduction = .2;
+	}
+	if (severity > .6) statusEffects.push(BREAKING_STATUS_EFFECT_IDS.BLEEDING);
+	return {
+		success: true,
+		target,
+		severity,
+		damage: effectiveForce,
+		mobilityReduction,
+		statusEffects
+	};
+}
+/**
+* Check if a defender can execute a counter-attack.
+*
+* **Korean**: 반격 실행 가능 여부 확인
+*
+* Validates whether a defender is in position and has the resources
+* to execute a counter-attack against an exposed limb.
+*
+* @param defenderStamina - Defender's current stamina
+* @param counterTechnique - The counter technique to execute
+* @param distance - Distance between attacker and defender (meters)
+* @returns Whether the counter can be executed
+*
+* @public
+* @korean 반격실행가능확인
+*/
+function canExecuteCounter(defenderStamina, counterTechnique, distance) {
+	if (defenderStamina < counterTechnique.staminaCost) return false;
+	if (distance > MAX_COUNTER_RANGE_METERS) return false;
+	return true;
+}
+/**
+* Generate limb exposure window for a technique.
+*
+* **Korean**: 사지 노출 시간 생성
+*
+* Creates a default limb exposure window for techniques that don't
+* explicitly define one, based on heuristics from the technique type
+* and reach configuration.
+*
+* @param technique - The technique to generate exposure for
+* @returns Generated limb exposure window
+*
+* @public
+* @korean 사지노출시간생성
+*/
+function generateLimbExposureWindow(technique) {
+	const { reachConfig, executionTime } = technique;
+	const exposedLimb = determineExposedLimb(technique);
+	const isHighExtension = reachConfig.baseExtension > 1;
+	const isMediumExtension = reachConfig.baseExtension > .8;
+	let vulnerabilityMultiplier;
+	let allowsBreaking;
+	if (isHighExtension) {
+		vulnerabilityMultiplier = 2.2;
+		allowsBreaking = true;
+	} else if (isMediumExtension) {
+		vulnerabilityMultiplier = 1.6;
+		allowsBreaking = false;
+	} else {
+		vulnerabilityMultiplier = 1.2;
+		allowsBreaking = false;
+	}
+	return {
+		exposedLimb,
+		startTime: .5,
+		duration: Math.floor(executionTime * (isHighExtension ? .4 : .25)),
+		vulnerabilityMultiplier,
+		allowsBreaking
+	};
+}
+//#endregion
+export { calculateBreakingResult, calculateCounterOpportunity, calculateVulnerabilityMultiplier, canExecuteCounter, determineExposedLimb, generateLimbExposureWindow, mapLimbToBreakingTarget };
+
+//# sourceMappingURL=LimbExposureSystem.js.map

package/lib/systems/combat/LimbExposureSystem.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"LimbExposureSystem.js","names":[],"sources":["../../../src/systems/combat/LimbExposureSystem.ts"],"sourcesContent":["/**\n * Limb Exposure System for Counter-Attack Detection\n *\n * **Korean**: 사지 노출 시스템 (Saji Nochul System)\n *\n * Analyzes technique animations to determine when limbs become exposed and vulnerable\n * during attack execution. This enables:\n * - Defensive counter-attacks (반격 - banggyeok)\n * - Breaking techniques (파쇄기 - paswaegi)\n * - Exploiting overextension (과다신장 약점 - gwada sinjang yakjeom)\n *\n * **Martial Arts Philosophy**:\n * - **허점공격** (Heojeom Gonggyeok) - Attacking openings/weaknesses\n * - **후수필승** (Husu Pilseung) - Victory through counter-attack timing\n * - **이순응변** (Isun Eungbyeon) - Adapt and exploit opponent's mistakes\n *\n * @module systems/combat/LimbExposureSystem\n * @korean 사지노출시스템\n */\n\nimport type { KoreanTechnique } from \"../vitalpoint/types\";\nimport type {\n  BreakingResult,\n  BreakingTarget,\n  CounterOpportunity,\n  ExposedLimbType,\n  LimbExposureWindow,\n  PhysicalReachConfig,\n} from \"../../types/physics\";\nimport { BREAKING_STATUS_EFFECT_IDS } from \"./BreakingStatusEffects\";\n\n/**\n * Breaking technique constants\n * **Korean**: 파쇄기술 상수\n */\n\n/**\n * Minimum effective force required to successfully execute a breaking technique.\n * Force below this threshold will not break joints/bones.\n * Typical damage values range from 20-80, with 40 being the minimum for effective breaks.\n * @korean 파쇄최소힘\n */\nconst BREAKING_FORCE_THRESHOLD = 40;\n\n/**\n * Maximum effective force for calculating break severity on 0-1 scale.\n * Force values above 80 are clamped to 1.0 severity (complete break).\n * @korean 파쇄최대힘\n */\nconst BREAKING_MAX_FORCE = 80;\n\n/**\n * Maximum range in meters for executing counter-attacks.\n * Counter-attacks are close-range defensive techniques requiring proximity.\n * @korean 반격최대거리\n */\nconst MAX_COUNTER_RANGE_METERS = 1.0;\n\n/**\n * Calculate counter-attack opportunities from a technique's reach configuration.\n *\n * **Korean**: 반격 기회 계산\n *\n * Analyzes the technique's execution timeline and limb exposure to identify\n * windows where the opponent is vulnerable to counter-attacks.\n *\n * @param technique - The technique being executed\n * @param currentTime - Current time in technique execution (ms)\n * @returns Counter opportunity if one exists, undefined otherwise\n *\n * @public\n * @korean 반격기회계산\n */\nexport function calculateCounterOpportunity(\n  technique: KoreanTechnique,\n  currentTime: number\n): CounterOpportunity | undefined {\n  const { reachConfig, executionTime } = technique;\n\n  // No exposure window defined, no counter opportunity\n  if (!reachConfig.exposureWindow) {\n    return undefined;\n  }\n\n  const exposure = reachConfig.exposureWindow;\n\n  // Calculate absolute timing of exposure window\n  const windowStart = executionTime * exposure.startTime;\n  const windowEnd = windowStart + exposure.duration;\n\n  // Check if current time is within the exposure window\n  if (currentTime < windowStart || currentTime > windowEnd) {\n    return undefined;\n  }\n\n  // Determine recommended counter techniques based on exposed limb\n  const recommendedCounters = getRecommendedCounters(\n    exposure.exposedLimb,\n    reachConfig,\n    exposure.allowsBreaking\n  );\n\n  return {\n    exposedLimb: exposure.exposedLimb,\n    windowStart,\n    windowDuration: exposure.duration,\n    vulnerabilityMultiplier: exposure.vulnerabilityMultiplier,\n    allowsBreaking: exposure.allowsBreaking,\n    recommendedCounters,\n  };\n}\n\n/**\n * Get recommended counter-technique IDs for an exposed limb.\n *\n * **Korean**: 추천 반격 기술 조회\n *\n * Returns technique IDs that would be effective against the exposed limb.\n * These IDs are string-based and should match techniques in the game's\n * technique library. When implementing, validate these IDs exist.\n *\n * **Note**: These are example/placeholder IDs. Actual implementation should\n * reference real technique definitions or use a typed enum of technique IDs.\n *\n * @param exposedLimb - The limb that is exposed\n * @param reachConfig - Reach configuration of the attacking technique\n * @param allowsBreaking - Whether breaking techniques are viable\n * @returns Array of recommended counter-technique IDs (unvalidated strings)\n *\n * @internal\n * @korean 추천반격기술조회\n */\nfunction getRecommendedCounters(\n  exposedLimb: ExposedLimbType,\n  reachConfig: PhysicalReachConfig,\n  allowsBreaking: boolean\n): readonly string[] {\n  const counters: string[] = [];\n\n  // Breaking techniques for overextended limbs\n  if (allowsBreaking) {\n    if (exposedLimb.includes(\"leg\") || exposedLimb.includes(\"ankle\")) {\n      counters.push(\"leg_sweep\", \"ankle_break\", \"knee_stomp\");\n    } else if (exposedLimb.includes(\"knee\")) {\n      counters.push(\"knee_break\", \"hyperextension_kick\");\n    } else if (exposedLimb.includes(\"arm\") || exposedLimb.includes(\"elbow\")) {\n      counters.push(\"arm_bar\", \"elbow_break\", \"joint_lock\");\n    } else if (exposedLimb.includes(\"wrist\")) {\n      counters.push(\"wrist_lock\", \"wrist_break\");\n    }\n  }\n\n  // Vital point strikes on exposed limbs\n  if (exposedLimb.includes(\"arm\")) {\n    counters.push(\"ulnar_nerve_strike\", \"radial_nerve_pressure\");\n  } else if (exposedLimb.includes(\"leg\")) {\n    counters.push(\"peroneal_nerve_strike\", \"thigh_pressure_point\");\n  }\n\n  // Counter-strikes based on body part type\n  if (reachConfig.bodyPart === \"leg\") {\n    counters.push(\"leg_parry_counter\", \"inside_leg_kick\");\n  } else if (reachConfig.bodyPart === \"arm\") {\n    counters.push(\"arm_trap_counter\", \"redirect_punch\");\n  }\n\n  return counters;\n}\n\n/**\n * Calculate vulnerability multiplier for a technique at a specific time.\n *\n * **Korean**: 취약성 배수 계산\n *\n * Determines how vulnerable the attacker is at a given point in their\n * technique execution. Useful for damage calculation during counter-attacks.\n *\n * @param technique - The technique being executed\n * @param currentTime - Current time in technique execution (ms)\n * @returns Vulnerability multiplier (1.0 = normal, >1.0 = more vulnerable)\n *\n * @public\n * @korean 취약성배수계산\n */\nexport function calculateVulnerabilityMultiplier(\n  technique: KoreanTechnique,\n  currentTime: number\n): number {\n  const { reachConfig, executionTime, recoveryTime } = technique;\n\n  // No exposure window, return baseline vulnerability\n  if (!reachConfig.exposureWindow) {\n    return 1.0;\n  }\n\n  const exposure = reachConfig.exposureWindow;\n  const windowStart = executionTime * exposure.startTime;\n  const windowEnd = windowStart + exposure.duration;\n\n  // Before exposure window: slight vulnerability during wind-up\n  if (currentTime < windowStart) {\n    return 1.1;\n  }\n\n  // Within exposure window: maximum vulnerability\n  if (currentTime <= windowEnd) {\n    return exposure.vulnerabilityMultiplier;\n  }\n\n  // Recovery phase: moderate vulnerability\n  const recoveryStart = executionTime;\n  const recoveryEnd = executionTime + recoveryTime;\n  if (currentTime > recoveryStart && currentTime <= recoveryEnd) {\n    const recoveryProgress = (currentTime - recoveryStart) / recoveryTime;\n    // Linearly decrease from max vulnerability to baseline\n    return (\n      exposure.vulnerabilityMultiplier -\n      (exposure.vulnerabilityMultiplier - 1.0) * recoveryProgress\n    );\n  }\n\n  // After recovery: baseline vulnerability\n  return 1.0;\n}\n\n/**\n * Determine which limb is exposed based on technique and animation state.\n *\n * **Korean**: 노출된 사지 결정\n *\n * Analyzes the technique's body part and animation to determine which\n * specific limb (left/right) is currently exposed.\n *\n * @param technique - The technique being executed\n * @param isLeftSided - Whether the technique uses the left side\n * @returns The exposed limb type\n *\n * @public\n * @korean 노출사지결정\n */\nexport function determineExposedLimb(\n  technique: KoreanTechnique,\n  isLeftSided: boolean = false\n): ExposedLimbType {\n  const { reachConfig } = technique;\n\n  // If exposure window explicitly defines the limb, use it\n  if (reachConfig.exposureWindow?.exposedLimb) {\n    return reachConfig.exposureWindow.exposedLimb;\n  }\n\n  // Otherwise, infer from body part and sidedness\n  const side = isLeftSided ? \"left\" : \"right\";\n\n  switch (reachConfig.bodyPart) {\n    case \"arm\":\n      // Determine joint based on reach extension\n      if (reachConfig.baseExtension > 0.8) {\n        return `${side}_arm` as ExposedLimbType;\n      } else if (reachConfig.baseExtension > 0.5) {\n        return `${side}_elbow` as ExposedLimbType;\n      } else {\n        return `${side}_wrist` as ExposedLimbType;\n      }\n\n    case \"leg\":\n      // Kicks expose different parts based on extension\n      if (reachConfig.baseExtension > 1.0) {\n        return `${side}_leg` as ExposedLimbType;\n      } else if (reachConfig.baseExtension > 0.7) {\n        return `${side}_knee` as ExposedLimbType;\n      } else {\n        return `${side}_ankle` as ExposedLimbType;\n      }\n\n    case \"torso\":\n      // Torso techniques typically expose arms\n      return `${side}_arm` as ExposedLimbType;\n\n    default:\n      return \"right_arm\";\n  }\n}\n\n/**\n * Map exposed limb to breaking technique target.\n *\n * **Korean**: 노출 사지를 파쇄 목표로 매핑\n *\n * Converts an exposed limb type to the appropriate breaking target\n * for joint and limb breaking techniques.\n *\n * @param exposedLimb - The exposed limb\n * @returns The breaking target joint/bone\n *\n * @public\n * @korean 파쇄목표매핑\n */\nexport function mapLimbToBreakingTarget(\n  exposedLimb: ExposedLimbType\n): BreakingTarget {\n  if (exposedLimb.includes(\"ankle\")) return \"ankle\";\n  if (exposedLimb.includes(\"knee\")) return \"knee\";\n  if (exposedLimb.includes(\"elbow\")) return \"elbow\";\n  if (exposedLimb.includes(\"wrist\")) return \"wrist\";\n\n  // Default mapping for general limbs\n  if (exposedLimb.includes(\"leg\")) return \"knee\";\n  if (exposedLimb.includes(\"arm\")) return \"elbow\";\n\n  return \"elbow\"; // Default fallback\n}\n\n/**\n * Calculate breaking technique effectiveness.\n *\n * **Korean**: 파쇄 기술 효과 계산\n *\n * Determines the result of a breaking technique applied to an exposed limb,\n * considering the vulnerability window, force applied, and target joint.\n *\n * @param breakingTechnique - The breaking technique being applied (reserved for future use)\n * @param counterOpportunity - The counter opportunity being exploited\n * @param force - Force/damage of the breaking technique (typically 20-80 range)\n * @returns Result of the breaking attempt\n *\n * @remarks\n * The breakingTechnique parameter is currently unused but reserved for future\n * extensibility. It may be used to apply technique-specific modifiers or\n * validate technique compatibility with the breaking target.\n *\n * @public\n * @korean 파쇄기술효과계산\n */\nexport function calculateBreakingResult(\n  breakingTechnique: KoreanTechnique,\n  counterOpportunity: CounterOpportunity,\n  force: number\n): BreakingResult {\n  // Note: breakingTechnique parameter reserved for future use\n  // (e.g., technique-specific breaking modifiers)\n  void breakingTechnique;\n  const target = mapLimbToBreakingTarget(counterOpportunity.exposedLimb);\n\n  // Breaking only works during valid windows\n  if (!counterOpportunity.allowsBreaking) {\n    return {\n      success: false,\n      target,\n      severity: 0,\n      damage: force * 0.5, // Reduced damage without breaking\n      mobilityReduction: 0,\n      statusEffects: [],\n    };\n  }\n\n  // Calculate breaking severity based on force and vulnerability\n  const effectiveForce = force * counterOpportunity.vulnerabilityMultiplier;\n  const baseSuccess = effectiveForce > BREAKING_FORCE_THRESHOLD;\n  const severity = Math.min(effectiveForce / BREAKING_MAX_FORCE, 1.0);\n\n  if (!baseSuccess) {\n    return {\n      success: false,\n      target,\n      severity: 0,\n      damage: effectiveForce * 0.7,\n      mobilityReduction: 0,\n      statusEffects: [],\n    };\n  }\n\n  // Successful break - apply appropriate effects\n  // Status effect IDs from BREAKING_STATUS_EFFECT_IDS constants\n  // See src/systems/combat/BreakingStatusEffects.ts for all available IDs\n  const statusEffects: string[] = [BREAKING_STATUS_EFFECT_IDS.PAIN];\n  let mobilityReduction: number;\n\n  // Severity-based effects\n  if (severity > 0.8) {\n    // Severe break - dislocation or fracture\n    statusEffects.push(\n      BREAKING_STATUS_EFFECT_IDS.SEVERE_INJURY,\n      BREAKING_STATUS_EFFECT_IDS.DISABLED_LIMB\n    );\n    mobilityReduction = 0.6;\n\n    if (target === \"ankle\" || target === \"knee\") {\n      statusEffects.push(BREAKING_STATUS_EFFECT_IDS.IMPAIRED_MOBILITY);\n      mobilityReduction = 0.8; // Leg breaks severely impact movement\n    }\n  } else if (severity > 0.5) {\n    // Moderate break\n    statusEffects.push(BREAKING_STATUS_EFFECT_IDS.INJURED_LIMB);\n    mobilityReduction = 0.4;\n  } else {\n    // Minor break - sprain or strain\n    statusEffects.push(BREAKING_STATUS_EFFECT_IDS.SPRAINED_JOINT);\n    mobilityReduction = 0.2;\n  }\n\n  // Bleeding for bone breaks\n  if (severity > 0.6) {\n    statusEffects.push(BREAKING_STATUS_EFFECT_IDS.BLEEDING);\n  }\n\n  return {\n    success: true,\n    target,\n    severity,\n    damage: effectiveForce,\n    mobilityReduction,\n    statusEffects,\n  };\n}\n\n/**\n * Check if a defender can execute a counter-attack.\n *\n * **Korean**: 반격 실행 가능 여부 확인\n *\n * Validates whether a defender is in position and has the resources\n * to execute a counter-attack against an exposed limb.\n *\n * @param defenderStamina - Defender's current stamina\n * @param counterTechnique - The counter technique to execute\n * @param distance - Distance between attacker and defender (meters)\n * @returns Whether the counter can be executed\n *\n * @public\n * @korean 반격실행가능확인\n */\nexport function canExecuteCounter(\n  defenderStamina: number,\n  counterTechnique: KoreanTechnique,\n  distance: number\n): boolean {\n  // Check stamina requirement\n  if (defenderStamina < counterTechnique.staminaCost) {\n    return false;\n  }\n\n  // Counter must be executable at current distance\n  if (distance > MAX_COUNTER_RANGE_METERS) {\n    return false;\n  }\n\n  return true;\n}\n\n/**\n * Generate limb exposure window for a technique.\n *\n * **Korean**: 사지 노출 시간 생성\n *\n * Creates a default limb exposure window for techniques that don't\n * explicitly define one, based on heuristics from the technique type\n * and reach configuration.\n *\n * @param technique - The technique to generate exposure for\n * @returns Generated limb exposure window\n *\n * @public\n * @korean 사지노출시간생성\n */\nexport function generateLimbExposureWindow(\n  technique: KoreanTechnique\n): LimbExposureWindow {\n  const { reachConfig, executionTime } = technique;\n  const exposedLimb = determineExposedLimb(technique);\n\n  // High extension = high vulnerability\n  const isHighExtension = reachConfig.baseExtension > 1.0;\n  const isMediumExtension = reachConfig.baseExtension > 0.8;\n\n  // Determine vulnerability based on extension\n  let vulnerabilityMultiplier: number;\n  let allowsBreaking: boolean;\n\n  if (isHighExtension) {\n    vulnerabilityMultiplier = 2.2; // Very vulnerable\n    allowsBreaking = true;\n  } else if (isMediumExtension) {\n    vulnerabilityMultiplier = 1.6;\n    allowsBreaking = false;\n  } else {\n    vulnerabilityMultiplier = 1.2; // Low extension, low vulnerability\n    allowsBreaking = false;\n  }\n\n  // Exposure starts during peak extension (typically 40-60% of execution)\n  const startTime = 0.5;\n\n  // Duration scales with execution time (20-40% of execution)\n  const durationRatio = isHighExtension ? 0.4 : 0.25;\n  const duration = Math.floor(executionTime * durationRatio);\n\n  return {\n    exposedLimb,\n    startTime,\n    duration,\n    vulnerabilityMultiplier,\n    allowsBreaking,\n  };\n}\n\nexport default {\n  calculateCounterOpportunity,\n  calculateVulnerabilityMultiplier,\n  determineExposedLimb,\n  mapLimbToBreakingTarget,\n  calculateBreakingResult,\n  canExecuteCounter,\n  generateLimbExposureWindow,\n};\n"],"mappings":"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"}

package/lib/systems/combat/PainResponseSystem.d.ts

@@ -0,0 +1,299 @@
+/**
+ * Pain Response System for managing cumulative pain effects in combat.
+ *
+ * **Korean**: 고통 반응 시스템 (Pain Response System)
+ *
+ * Implements realistic pain accumulation that progressively reduces combat
+ * effectiveness. Unlike health, pain represents the body's protective response
+ * to damage, reducing capabilities before critical injury occurs.
+ *
+ * ## Pain Mechanics
+ *
+ * - **충격통 (Shock Pain)**: Instant reaction affecting all abilities (10-30% reduction for 2-3 seconds)
+ * - **누적외상 (Cumulative Trauma)**: Progressive damage impairment
+ * - **통증과부하 (Pain Overload)**: Complete incapacitation from overwhelming pain (>80 pain)
+ * - **무력화한계 (Incapacitation Threshold)**: Point of complete combat inability
+ *
+ * ## Pain Levels
+ *
+ * - **0-20**: Minimal pain - no significant effects
+ * - **20-40**: Moderate pain - slight performance reduction (-10%)
+ * - **40-60**: Significant pain - noticeable impairment (-20%)
+ * - **60-80**: Severe pain - major limitations (-35%)
+ * - **80-100**: Pain overload - chance of stun/unconsciousness, extreme impairment (-50%)
+ *
+ * @module systems/combat/PainResponseSystem
+ * @category Combat System
+ * @korean 고통반응시스템
+ */
+import { PlayerState } from "../player";
+import { VitalPointSeverity, VitalPointCategory } from "../../types";
+/**
+ * Pain level categories for status indication.
+ */
+export declare enum PainLevel {
+    /** Minimal pain (0-20) - no significant effects */
+    MINIMAL = "minimal",
+    /** Moderate pain (20-40) - slight performance reduction (-10%) */
+    MODERATE = "moderate",
+    /** Significant pain (40-60) - noticeable impairment (-20%) */
+    SIGNIFICANT = "significant",
+    /** Severe pain (60-80) - major limitations (-35%) */
+    SEVERE = "severe",
+    /** Pain overload (80-100) - chance of stun/unconsciousness, extreme impairment (-50%) */
+    OVERLOAD = "overload"
+}
+/**
+ * Shock pain effect from sudden trauma.
+ *
+ * **Korean**: 충격통 효과 (Shock Pain Effect)
+ *
+ * Represents instant reaction to damage affecting all abilities for 2-3 seconds.
+ */
+export interface ShockPainEffect {
+    /** Intensity of shock pain (0.1-0.3 for 10-30% reduction) */
+    readonly intensity: number;
+    /** Duration remaining in milliseconds (2000-3000ms) */
+    readonly duration: number;
+    /** Timestamp when shock pain was applied */
+    readonly startTime: number;
+    /** Damage value that caused the shock */
+    readonly causedByDamage: number;
+}
+/**
+ * Effects of pain on combat performance.
+ */
+interface PainEffects {
+    /** Pain value range */
+    readonly range: readonly [number, number];
+    /** Overall performance penalty multiplier */
+    readonly performancePenalty: number;
+    /** Accuracy reduction */
+    readonly accuracyReduction: number;
+    /** Damage output reduction */
+    readonly damageReduction: number;
+    /** Movement speed reduction */
+    readonly speedReduction: number;
+    /** Chance of involuntary stun (0-1) */
+    readonly stunChance: number;
+}
+/**
+ * Pain Response System managing cumulative pain effects.
+ *
+ * Pain accumulates from all damage sources and reduces combat effectiveness
+ * progressively. High pain can incapacitate even if health remains adequate.
+ * Pain dissipates slowly over time.
+ *
+ * @example
+ * ```typescript
+ * const painSystem = new PainResponseSystem();
+ *
+ * // Apply pain from damage
+ * const newPlayer = painSystem.applyPain(player, 15, VitalPointSeverity.MAJOR);
+ *
+ * // Check pain level
+ * const level = painSystem.getPainLevel(newPlayer.pain);
+ *
+ * // Apply dissipation over time
+ * const recovered = painSystem.applyDissipation(newPlayer, 1000);
+ * ```
+ *
+ * @public
+ * @korean 고통반응시스템
+ */
+export declare class PainResponseSystem {
+    /**
+     * Pain level effects and thresholds matching requirements.
+     */
+    private readonly painEffects;
+    /**
+     * Pain multipliers by vital point severity.
+     */
+    private readonly severityMultipliers;
+    /**
+     * Pain multipliers by vital point category.
+     */
+    private readonly categoryMultipliers;
+    /**
+     * Base pain dissipation rate per second (requirement: -5 pain/second).
+     */
+    private readonly BASE_DISSIPATION_RATE;
+    /**
+     * Shock pain duration range in milliseconds (requirement: 2-3 seconds).
+     */
+    private readonly SHOCK_PAIN_DURATION;
+    /**
+     * Minimum damage to trigger shock pain.
+     */
+    private readonly SHOCK_PAIN_THRESHOLD;
+    /**
+     * Pain overload threshold for stun chance (requirement: >80).
+     */
+    private readonly PAIN_OVERLOAD_THRESHOLD;
+    /**
+     * Shock pain intensity constants.
+     */
+    private readonly MAX_SHOCK_INTENSITY;
+    private readonly MIN_SHOCK_INTENSITY;
+    private readonly DAMAGE_SCALE_FACTOR;
+    private readonly INTENSITY_RANGE;
+    /**
+     * Pain to damage ratio for cumulative trauma calculation.
+     */
+    private readonly PAIN_TO_DAMAGE_RATIO;
+    /**
+     * Applies pain from combat damage with shock pain effects.
+     *
+     * Calculates pain increase based on damage amount, vital point severity,
+     * and vital point category. Also determines if shock pain effect should be triggered.
+     *
+     * **Shock Pain**: Instant 10-30% reduction for 2-3 seconds on significant hits (>=10 damage)
+     * **Cumulative Trauma**: Progressive pain accumulation that reduces performance
+     * **Pain Overload**: At >80 pain, chance of stun/unconsciousness
+     *
+     * @param player - Current player state
+     * @param damage - Base damage amount
+     * @param severity - Optional vital point severity
+     * @param category - Optional vital point category for more accurate pain calculation
+     * @returns Updated player state with increased pain and optional shock effect
+     *
+     * @example
+     * ```typescript
+     * // Normal hit
+     * const result = system.applyPain(player, 10);
+     *
+     * // Vital point neurological hit with shock pain
+     * const result = system.applyPain(
+     *   player,
+     *   20,
+     *   VitalPointSeverity.MAJOR,
+     *   VitalPointCategory.NEUROLOGICAL
+     * );
+     * if (result.shockEffect) {
+     *   console.log(`Shock pain active for ${result.shockEffect.duration}ms`);
+     * }
+     * ```
+     *
+     * @public
+     * @korean 고통적용
+     */
+    applyPain(player: PlayerState, damage: number, severity?: VitalPointSeverity, category?: VitalPointCategory): {
+        player: PlayerState;
+        shockEffect?: ShockPainEffect;
+    };
+    /**
+     * Applies pain dissipation over time (requirement: -5 pain/second).
+     *
+     * Pain naturally dissipates when not taking damage at a constant rate
+     * of -5 pain per second.
+     *
+     * @param player - Current player state
+     * @param deltaTime - Time elapsed in milliseconds
+     * @returns Updated player state with reduced pain
+     *
+     * @example
+     * ```typescript
+     * // In game loop (~60fps, 16ms per frame)
+     * player = system.applyDissipation(player, 16);
+     * ```
+     *
+     * @public
+     * @korean 고통감소
+     */
+    applyDissipation(player: PlayerState, deltaTime: number): PlayerState;
+    /**
+     * Determines pain level from pain value.
+     *
+     * @param pain - Pain value (0-100)
+     * @returns Current pain level
+     *
+     * @public
+     * @korean 고통수준확인
+     */
+    getPainLevel(pain: number): PainLevel;
+    /**
+     * Gets effects for a specific pain level.
+     *
+     * @param level - Pain level
+     * @returns Effects applied at that level
+     *
+     * @public
+     * @korean 고통효과
+     */
+    getEffects(level: PainLevel): PainEffects;
+    /**
+     * Applies pain effects to player state, including shock pain.
+     *
+     * Modifies player stats based on current pain level. When shock pain
+     * is active, additional penalties are applied temporarily.
+     *
+     * @param player - Current player state
+     * @param shockEffect - Optional active shock pain effect
+     * @returns Modified player state with pain effects
+     *
+     * @public
+     * @korean 고통효과적용
+     */
+    applyEffects(player: PlayerState, shockEffect?: ShockPainEffect): PlayerState;
+    /**
+     * Checks if pain overload should trigger stun.
+     *
+     * At pain >80, there's a chance per hit to trigger stun based on pain level.
+     * Pain Overload level has 30% chance to trigger stun.
+     *
+     * @param player - Current player state
+     * @returns True if player should be stunned from pain
+     *
+     * @public
+     * @korean 고통기절확인
+     */
+    shouldTriggerStun(player: PlayerState): boolean;
+    /**
+     * Checks if player is in pain overload state (>80 pain).
+     *
+     * @param player - Current player state
+     * @returns True if pain is above overload threshold
+     *
+     * @public
+     * @korean 고통과부하확인
+     */
+    isInPainOverload(player: PlayerState): boolean;
+    /**
+     * Checks if player is incapacitated by pain.
+     *
+     * @param player - Current player state
+     * @returns True if pain is at overload level
+     *
+     * @public
+     * @korean 고통무력화확인
+     */
+    isIncapacitated(player: PlayerState): boolean;
+    /**
+     * Gets bilingual name for pain level.
+     *
+     * @param level - Pain level
+     * @returns Korean and English level names
+     *
+     * @public
+     * @korean 고통이름
+     */
+    getLevelName(level: PainLevel): {
+        korean: string;
+        english: string;
+    };
+    /**
+     * Gets description of pain level effects.
+     *
+     * @param level - Pain level
+     * @returns Bilingual description
+     *
+     * @public
+     * @korean 고통설명
+     */
+    getLevelDescription(level: PainLevel): {
+        korean: string;
+        english: string;
+    };
+}
+export default PainResponseSystem;
+//# sourceMappingURL=PainResponseSystem.d.ts.map

package/lib/systems/combat/PainResponseSystem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PainResponseSystem.d.ts","sourceRoot":"","sources":["../../../src/systems/combat/PainResponseSystem.ts"],"names":[],"mappings":"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"}