blacktrigram 0.7.2

package/lib/systems/combat/PainResponseSystem.js

@@ -0,0 +1,401 @@
+import { VitalPointCategory, VitalPointSeverity } from "../../types/common.js";
+import "../../types/index.js";
+//#region src/systems/combat/PainResponseSystem.ts
+/**
+* Pain level categories for status indication.
+*/
+var PainLevel = /* @__PURE__ */ function(PainLevel) {
+	/** Minimal pain (0-20) - no significant effects */
+	PainLevel["MINIMAL"] = "minimal";
+	/** Moderate pain (20-40) - slight performance reduction (-10%) */
+	PainLevel["MODERATE"] = "moderate";
+	/** Significant pain (40-60) - noticeable impairment (-20%) */
+	PainLevel["SIGNIFICANT"] = "significant";
+	/** Severe pain (60-80) - major limitations (-35%) */
+	PainLevel["SEVERE"] = "severe";
+	/** Pain overload (80-100) - chance of stun/unconsciousness, extreme impairment (-50%) */
+	PainLevel["OVERLOAD"] = "overload";
+	return PainLevel;
+}({});
+/**
+* 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 고통반응시스템
+*/
+var PainResponseSystem = class {
+	/**
+	* Pain level effects and thresholds matching requirements.
+	*/
+	painEffects = {
+		[PainLevel.MINIMAL]: {
+			range: [0, 20],
+			performancePenalty: 0,
+			accuracyReduction: 0,
+			damageReduction: 0,
+			speedReduction: 0,
+			stunChance: 0
+		},
+		[PainLevel.MODERATE]: {
+			range: [20, 40],
+			performancePenalty: .1,
+			accuracyReduction: .1,
+			damageReduction: .1,
+			speedReduction: .05,
+			stunChance: 0
+		},
+		[PainLevel.SIGNIFICANT]: {
+			range: [40, 60],
+			performancePenalty: .2,
+			accuracyReduction: .2,
+			damageReduction: .2,
+			speedReduction: .15,
+			stunChance: .05
+		},
+		[PainLevel.SEVERE]: {
+			range: [60, 80],
+			performancePenalty: .35,
+			accuracyReduction: .35,
+			damageReduction: .35,
+			speedReduction: .25,
+			stunChance: .15
+		},
+		[PainLevel.OVERLOAD]: {
+			range: [80, 100],
+			performancePenalty: .5,
+			accuracyReduction: .5,
+			damageReduction: .5,
+			speedReduction: .4,
+			stunChance: .3
+		}
+	};
+	/**
+	* Pain multipliers by vital point severity.
+	*/
+	severityMultipliers = {
+		[VitalPointSeverity.MINOR]: .5,
+		[VitalPointSeverity.MODERATE]: 1,
+		[VitalPointSeverity.MAJOR]: 1.5,
+		[VitalPointSeverity.CRITICAL]: 2,
+		[VitalPointSeverity.LETHAL]: 3
+	};
+	/**
+	* Pain multipliers by vital point category.
+	*/
+	categoryMultipliers = {
+		[VitalPointCategory.NEUROLOGICAL]: 2.5,
+		[VitalPointCategory.VASCULAR]: 1.5,
+		[VitalPointCategory.RESPIRATORY]: 2,
+		[VitalPointCategory.SKELETAL]: 1.8,
+		[VitalPointCategory.MUSCULAR]: 1.4,
+		[VitalPointCategory.ORGAN]: 2.2,
+		[VitalPointCategory.JOINT]: 1.9,
+		[VitalPointCategory.CIRCULATORY]: 1.6,
+		default: 1
+	};
+	/**
+	* Base pain dissipation rate per second (requirement: -5 pain/second).
+	*/
+	BASE_DISSIPATION_RATE = 5;
+	/**
+	* Shock pain duration range in milliseconds (requirement: 2-3 seconds).
+	*/
+	SHOCK_PAIN_DURATION = {
+		min: 2e3,
+		max: 3e3
+	};
+	/**
+	* Minimum damage to trigger shock pain.
+	*/
+	SHOCK_PAIN_THRESHOLD = 10;
+	/**
+	* Pain overload threshold for stun chance (requirement: >80).
+	*/
+	PAIN_OVERLOAD_THRESHOLD = 80;
+	/**
+	* Shock pain intensity constants.
+	*/
+	MAX_SHOCK_INTENSITY = .3;
+	MIN_SHOCK_INTENSITY = .1;
+	DAMAGE_SCALE_FACTOR = 100;
+	INTENSITY_RANGE = .2;
+	/**
+	* Pain to damage ratio for cumulative trauma calculation.
+	*/
+	PAIN_TO_DAMAGE_RATIO = .5;
+	/**
+	* 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, damage, severity, category) {
+		const severityMultiplier = severity ? this.severityMultipliers[severity] : 1;
+		const categoryMultiplier = category ? this.categoryMultipliers[category] ?? this.categoryMultipliers.default : this.categoryMultipliers.default;
+		const painIncrease = damage * severityMultiplier * categoryMultiplier * this.PAIN_TO_DAMAGE_RATIO;
+		const newPain = Math.max(0, Math.min(100, player.pain + painIncrease));
+		let shockEffect;
+		if (damage >= this.SHOCK_PAIN_THRESHOLD) shockEffect = {
+			intensity: Math.min(this.MAX_SHOCK_INTENSITY, this.MIN_SHOCK_INTENSITY + damage / this.DAMAGE_SCALE_FACTOR * this.INTENSITY_RANGE),
+			duration: this.SHOCK_PAIN_DURATION.min + Math.random() * (this.SHOCK_PAIN_DURATION.max - this.SHOCK_PAIN_DURATION.min),
+			startTime: Date.now(),
+			causedByDamage: damage
+		};
+		return {
+			player: {
+				...player,
+				pain: newPain
+			},
+			shockEffect
+		};
+	}
+	/**
+	* 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, deltaTime) {
+		if (player.pain <= 0) return player;
+		const deltaSeconds = deltaTime / 1e3;
+		const dissipation = this.BASE_DISSIPATION_RATE * deltaSeconds;
+		const newPain = Math.max(0, player.pain - dissipation);
+		return {
+			...player,
+			pain: newPain
+		};
+	}
+	/**
+	* Determines pain level from pain value.
+	* 
+	* @param pain - Pain value (0-100)
+	* @returns Current pain level
+	* 
+	* @public
+	* @korean 고통수준확인
+	*/
+	getPainLevel(pain) {
+		if (pain >= 80) return PainLevel.OVERLOAD;
+		if (pain >= 60) return PainLevel.SEVERE;
+		if (pain >= 40) return PainLevel.SIGNIFICANT;
+		if (pain >= 20) return PainLevel.MODERATE;
+		return PainLevel.MINIMAL;
+	}
+	/**
+	* Gets effects for a specific pain level.
+	* 
+	* @param level - Pain level
+	* @returns Effects applied at that level
+	* 
+	* @public
+	* @korean 고통효과
+	*/
+	getEffects(level) {
+		return this.painEffects[level];
+	}
+	/**
+	* 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, shockEffect) {
+		const level = this.getPainLevel(player.pain);
+		const effects = this.getEffects(level);
+		let totalAccuracyPenalty = effects.accuracyReduction;
+		let totalDamagePenalty = effects.damageReduction;
+		if (shockEffect) {
+			if (Date.now() - shockEffect.startTime < shockEffect.duration) {
+				totalAccuracyPenalty = Math.min(1, totalAccuracyPenalty + shockEffect.intensity);
+				totalDamagePenalty = Math.min(1, totalDamagePenalty + shockEffect.intensity);
+			}
+		}
+		return {
+			...player,
+			attackPower: Math.floor(player.attackPower * (1 - totalDamagePenalty)),
+			defense: Math.floor(player.defense * (1 - effects.performancePenalty)),
+			speed: Math.floor(player.speed * (1 - effects.speedReduction)),
+			technique: Math.floor(player.technique * (1 - totalAccuracyPenalty))
+		};
+	}
+	/**
+	* 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) {
+		if (player.pain < this.PAIN_OVERLOAD_THRESHOLD) return false;
+		const level = this.getPainLevel(player.pain);
+		const effects = this.getEffects(level);
+		return Math.random() < effects.stunChance;
+	}
+	/**
+	* 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) {
+		return player.pain >= this.PAIN_OVERLOAD_THRESHOLD;
+	}
+	/**
+	* Checks if player is incapacitated by pain.
+	* 
+	* @param player - Current player state
+	* @returns True if pain is at overload level
+	* 
+	* @public
+	* @korean 고통무력화확인
+	*/
+	isIncapacitated(player) {
+		return this.getPainLevel(player.pain) === PainLevel.OVERLOAD;
+	}
+	/**
+	* Gets bilingual name for pain level.
+	* 
+	* @param level - Pain level
+	* @returns Korean and English level names
+	* 
+	* @public
+	* @korean 고통이름
+	*/
+	getLevelName(level) {
+		return {
+			[PainLevel.MINIMAL]: {
+				korean: "최소",
+				english: "Minimal"
+			},
+			[PainLevel.MODERATE]: {
+				korean: "보통",
+				english: "Moderate"
+			},
+			[PainLevel.SIGNIFICANT]: {
+				korean: "상당",
+				english: "Significant"
+			},
+			[PainLevel.SEVERE]: {
+				korean: "심각",
+				english: "Severe"
+			},
+			[PainLevel.OVERLOAD]: {
+				korean: "과부하",
+				english: "Overload"
+			}
+		}[level];
+	}
+	/**
+	* Gets description of pain level effects.
+	* 
+	* @param level - Pain level
+	* @returns Bilingual description
+	* 
+	* @public
+	* @korean 고통설명
+	*/
+	getLevelDescription(level) {
+		return {
+			[PainLevel.MINIMAL]: {
+				korean: "최소한의 고통, 전투 능력에 영향 없음",
+				english: "Minimal pain, no significant effects on combat"
+			},
+			[PainLevel.MODERATE]: {
+				korean: "보통 고통, 약간의 능력 저하 (-10%)",
+				english: "Moderate pain, slight performance reduction (-10%)"
+			},
+			[PainLevel.SIGNIFICANT]: {
+				korean: "상당한 고통, 명확한 손상 (-20%)",
+				english: "Significant pain, noticeable impairment (-20%)"
+			},
+			[PainLevel.SEVERE]: {
+				korean: "심각한 고통, 주요 제한 (-35%)",
+				english: "Severe pain, major limitations (-35%)"
+			},
+			[PainLevel.OVERLOAD]: {
+				korean: "고통 과부하, 기절 위험 (-50%, 30% 기절 확률)",
+				english: "Pain overload, stun risk (-50%, 30% stun chance)"
+			}
+		}[level];
+	}
+};
+//#endregion
+export { PainLevel, PainResponseSystem as default };
+
+//# sourceMappingURL=PainResponseSystem.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"PainResponseSystem.js","names":[],"sources":["../../../src/systems/combat/PainResponseSystem.ts"],"sourcesContent":["/**\n * Pain Response System for managing cumulative pain effects in combat.\n * \n * **Korean**: 고통 반응 시스템 (Pain Response System)\n * \n * Implements realistic pain accumulation that progressively reduces combat\n * effectiveness. Unlike health, pain represents the body's protective response\n * to damage, reducing capabilities before critical injury occurs.\n * \n * ## Pain Mechanics\n * \n * - **충격통 (Shock Pain)**: Instant reaction affecting all abilities (10-30% reduction for 2-3 seconds)\n * - **누적외상 (Cumulative Trauma)**: Progressive damage impairment\n * - **통증과부하 (Pain Overload)**: Complete incapacitation from overwhelming pain (>80 pain)\n * - **무력화한계 (Incapacitation Threshold)**: Point of complete combat inability\n * \n * ## Pain Levels\n * \n * - **0-20**: Minimal pain - no significant effects\n * - **20-40**: Moderate pain - slight performance reduction (-10%)\n * - **40-60**: Significant pain - noticeable impairment (-20%)\n * - **60-80**: Severe pain - major limitations (-35%)\n * - **80-100**: Pain overload - chance of stun/unconsciousness, extreme impairment (-50%)\n * \n * @module systems/combat/PainResponseSystem\n * @category Combat System\n * @korean 고통반응시스템\n */\n\nimport { PlayerState } from \"../player\";\nimport { VitalPointSeverity, VitalPointCategory } from \"@/types\";\n\n/**\n * Pain level categories for status indication.\n */\nexport enum PainLevel {\n  /** Minimal pain (0-20) - no significant effects */\n  MINIMAL = \"minimal\",\n  /** Moderate pain (20-40) - slight performance reduction (-10%) */\n  MODERATE = \"moderate\",\n  /** Significant pain (40-60) - noticeable impairment (-20%) */\n  SIGNIFICANT = \"significant\",\n  /** Severe pain (60-80) - major limitations (-35%) */\n  SEVERE = \"severe\",\n  /** Pain overload (80-100) - chance of stun/unconsciousness, extreme impairment (-50%) */\n  OVERLOAD = \"overload\",\n}\n\n/**\n * Shock pain effect from sudden trauma.\n * \n * **Korean**: 충격통 효과 (Shock Pain Effect)\n * \n * Represents instant reaction to damage affecting all abilities for 2-3 seconds.\n */\nexport interface ShockPainEffect {\n  /** Intensity of shock pain (0.1-0.3 for 10-30% reduction) */\n  readonly intensity: number;\n  /** Duration remaining in milliseconds (2000-3000ms) */\n  readonly duration: number;\n  /** Timestamp when shock pain was applied */\n  readonly startTime: number;\n  /** Damage value that caused the shock */\n  readonly causedByDamage: number;\n}\n\n/**\n * Effects of pain on combat performance.\n */\ninterface PainEffects {\n  /** Pain value range */\n  readonly range: readonly [number, number];\n  /** Overall performance penalty multiplier */\n  readonly performancePenalty: number;\n  /** Accuracy reduction */\n  readonly accuracyReduction: number;\n  /** Damage output reduction */\n  readonly damageReduction: number;\n  /** Movement speed reduction */\n  readonly speedReduction: number;\n  /** Chance of involuntary stun (0-1) */\n  readonly stunChance: number;\n}\n\n/**\n * Pain Response System managing cumulative pain effects.\n * \n * Pain accumulates from all damage sources and reduces combat effectiveness\n * progressively. High pain can incapacitate even if health remains adequate.\n * Pain dissipates slowly over time.\n * \n * @example\n * ```typescript\n * const painSystem = new PainResponseSystem();\n * \n * // Apply pain from damage\n * const newPlayer = painSystem.applyPain(player, 15, VitalPointSeverity.MAJOR);\n * \n * // Check pain level\n * const level = painSystem.getPainLevel(newPlayer.pain);\n * \n * // Apply dissipation over time\n * const recovered = painSystem.applyDissipation(newPlayer, 1000);\n * ```\n * \n * @public\n * @korean 고통반응시스템\n */\nexport class PainResponseSystem {\n  /**\n   * Pain level effects and thresholds matching requirements.\n   */\n  private readonly painEffects: Record<PainLevel, PainEffects> = {\n    [PainLevel.MINIMAL]: {\n      range: [0, 20],\n      performancePenalty: 0.0,\n      accuracyReduction: 0.0,\n      damageReduction: 0.0,\n      speedReduction: 0.0,\n      stunChance: 0.0,\n    },\n    [PainLevel.MODERATE]: {\n      range: [20, 40],\n      performancePenalty: 0.1, // -10% overall\n      accuracyReduction: 0.1,\n      damageReduction: 0.1,\n      speedReduction: 0.05,\n      stunChance: 0.0,\n    },\n    [PainLevel.SIGNIFICANT]: {\n      range: [40, 60],\n      performancePenalty: 0.2, // -20% overall\n      accuracyReduction: 0.2,\n      damageReduction: 0.2,\n      speedReduction: 0.15,\n      stunChance: 0.05, // 5% chance\n    },\n    [PainLevel.SEVERE]: {\n      range: [60, 80],\n      performancePenalty: 0.35, // -35% overall\n      accuracyReduction: 0.35,\n      damageReduction: 0.35,\n      speedReduction: 0.25,\n      stunChance: 0.15, // 15% chance\n    },\n    [PainLevel.OVERLOAD]: {\n      range: [80, 100],\n      performancePenalty: 0.5, // -50% overall\n      accuracyReduction: 0.5,\n      damageReduction: 0.5,\n      speedReduction: 0.4,\n      stunChance: 0.3, // 30% chance per hit at pain >80\n    },\n  };\n\n  /**\n   * Pain multipliers by vital point severity.\n   */\n  private readonly severityMultipliers: Record<VitalPointSeverity, number> = {\n    [VitalPointSeverity.MINOR]: 0.5,\n    [VitalPointSeverity.MODERATE]: 1.0,\n    [VitalPointSeverity.MAJOR]: 1.5,\n    [VitalPointSeverity.CRITICAL]: 2.0,\n    [VitalPointSeverity.LETHAL]: 3.0,\n  };\n\n  /**\n   * Pain multipliers by vital point category.\n   */\n  private readonly categoryMultipliers: Record<string, number> = {\n    [VitalPointCategory.NEUROLOGICAL]: 2.5, // Nerve strikes cause intense pain\n    [VitalPointCategory.VASCULAR]: 1.5, // Blood flow restriction\n    [VitalPointCategory.RESPIRATORY]: 2.0, // Breathing difficulty causes panic\n    [VitalPointCategory.SKELETAL]: 1.8, // Bone/structural damage\n    [VitalPointCategory.MUSCULAR]: 1.4, // Muscle trauma\n    [VitalPointCategory.ORGAN]: 2.2, // Internal organ trauma\n    [VitalPointCategory.JOINT]: 1.9, // Joint damage\n    [VitalPointCategory.CIRCULATORY]: 1.6, // Circulatory disruption\n    default: 1.0, // Standard damage\n  };\n\n  /**\n   * Base pain dissipation rate per second (requirement: -5 pain/second).\n   */\n  private readonly BASE_DISSIPATION_RATE = 5.0; // -5 pain per second\n\n  /**\n   * Shock pain duration range in milliseconds (requirement: 2-3 seconds).\n   */\n  private readonly SHOCK_PAIN_DURATION = {\n    min: 2000, // 2 seconds\n    max: 3000, // 3 seconds\n  };\n\n  /**\n   * Minimum damage to trigger shock pain.\n   */\n  private readonly SHOCK_PAIN_THRESHOLD = 10;\n\n  /**\n   * Pain overload threshold for stun chance (requirement: >80).\n   */\n  private readonly PAIN_OVERLOAD_THRESHOLD = 80;\n\n  /**\n   * Shock pain intensity constants.\n   */\n  private readonly MAX_SHOCK_INTENSITY = 0.3; // 30% max reduction\n  private readonly MIN_SHOCK_INTENSITY = 0.1; // 10% min reduction\n  private readonly DAMAGE_SCALE_FACTOR = 100; // for normalizing damage to 0-1 range\n  private readonly INTENSITY_RANGE = 0.2; // 20% variable range\n\n  /**\n   * Pain to damage ratio for cumulative trauma calculation.\n   */\n  private readonly PAIN_TO_DAMAGE_RATIO = 0.5;\n\n  /**\n   * Applies pain from combat damage with shock pain effects.\n   * \n   * Calculates pain increase based on damage amount, vital point severity,\n   * and vital point category. Also determines if shock pain effect should be triggered.\n   * \n   * **Shock Pain**: Instant 10-30% reduction for 2-3 seconds on significant hits (>=10 damage)\n   * **Cumulative Trauma**: Progressive pain accumulation that reduces performance\n   * **Pain Overload**: At >80 pain, chance of stun/unconsciousness\n   * \n   * @param player - Current player state\n   * @param damage - Base damage amount\n   * @param severity - Optional vital point severity\n   * @param category - Optional vital point category for more accurate pain calculation\n   * @returns Updated player state with increased pain and optional shock effect\n   * \n   * @example\n   * ```typescript\n   * // Normal hit\n   * const result = system.applyPain(player, 10);\n   * \n   * // Vital point neurological hit with shock pain\n   * const result = system.applyPain(\n   *   player, \n   *   20, \n   *   VitalPointSeverity.MAJOR,\n   *   VitalPointCategory.NEUROLOGICAL\n   * );\n   * if (result.shockEffect) {\n   *   console.log(`Shock pain active for ${result.shockEffect.duration}ms`);\n   * }\n   * ```\n   * \n   * @public\n   * @korean 고통적용\n   */\n  applyPain(\n    player: PlayerState,\n    damage: number,\n    severity?: VitalPointSeverity,\n    category?: VitalPointCategory\n  ): { player: PlayerState; shockEffect?: ShockPainEffect } {\n    // Get multipliers based on severity and category\n    const severityMultiplier = severity\n      ? this.severityMultipliers[severity]\n      : 1.0;\n    \n    const categoryMultiplier = category\n      ? this.categoryMultipliers[category] ?? this.categoryMultipliers.default\n      : this.categoryMultipliers.default;\n\n    // Calculate pain increase (cumulative trauma)\n    const painIncrease = damage * severityMultiplier * categoryMultiplier * this.PAIN_TO_DAMAGE_RATIO;\n\n    // Apply pain, clamped to 0-100\n    const newPain = Math.max(0, Math.min(100, player.pain + painIncrease));\n\n    let shockEffect: ShockPainEffect | undefined;\n\n    // Trigger shock pain for significant hits (>=10 damage)\n    if (damage >= this.SHOCK_PAIN_THRESHOLD) {\n      // Calculate shock intensity: 10-30% reduction based on damage\n      const shockIntensity = Math.min(\n        this.MAX_SHOCK_INTENSITY,\n        this.MIN_SHOCK_INTENSITY + (damage / this.DAMAGE_SCALE_FACTOR) * this.INTENSITY_RANGE\n      );\n      \n      // Random duration between 2-3 seconds\n      const shockDuration =\n        this.SHOCK_PAIN_DURATION.min +\n        Math.random() *\n          (this.SHOCK_PAIN_DURATION.max - this.SHOCK_PAIN_DURATION.min);\n\n      shockEffect = {\n        intensity: shockIntensity,\n        duration: shockDuration,\n        startTime: Date.now(),\n        causedByDamage: damage,\n      };\n    }\n\n    const updatedPlayer: PlayerState = {\n      ...player,\n      pain: newPain,\n    };\n\n    return { player: updatedPlayer, shockEffect };\n  }\n\n  /**\n   * Applies pain dissipation over time (requirement: -5 pain/second).\n   * \n   * Pain naturally dissipates when not taking damage at a constant rate\n   * of -5 pain per second.\n   * \n   * @param player - Current player state\n   * @param deltaTime - Time elapsed in milliseconds\n   * @returns Updated player state with reduced pain\n   * \n   * @example\n   * ```typescript\n   * // In game loop (~60fps, 16ms per frame)\n   * player = system.applyDissipation(player, 16);\n   * ```\n   * \n   * @public\n   * @korean 고통감소\n   */\n  applyDissipation(player: PlayerState, deltaTime: number): PlayerState {\n    // Already at zero pain\n    if (player.pain <= 0) {\n      return player;\n    }\n\n    const deltaSeconds = deltaTime / 1000;\n    \n    // Constant dissipation rate of -5 pain/second\n    const dissipation = this.BASE_DISSIPATION_RATE * deltaSeconds;\n    const newPain = Math.max(0, player.pain - dissipation);\n\n    return {\n      ...player,\n      pain: newPain,\n    };\n  }\n\n  /**\n   * Determines pain level from pain value.\n   * \n   * @param pain - Pain value (0-100)\n   * @returns Current pain level\n   * \n   * @public\n   * @korean 고통수준확인\n   */\n  getPainLevel(pain: number): PainLevel {\n    if (pain >= 80) return PainLevel.OVERLOAD;\n    if (pain >= 60) return PainLevel.SEVERE;\n    if (pain >= 40) return PainLevel.SIGNIFICANT;\n    if (pain >= 20) return PainLevel.MODERATE;\n    return PainLevel.MINIMAL;\n  }\n\n  /**\n   * Gets effects for a specific pain level.\n   * \n   * @param level - Pain level\n   * @returns Effects applied at that level\n   * \n   * @public\n   * @korean 고통효과\n   */\n  getEffects(level: PainLevel): PainEffects {\n    return this.painEffects[level];\n  }\n\n  /**\n   * Applies pain effects to player state, including shock pain.\n   * \n   * Modifies player stats based on current pain level. When shock pain\n   * is active, additional penalties are applied temporarily.\n   * \n   * @param player - Current player state\n   * @param shockEffect - Optional active shock pain effect\n   * @returns Modified player state with pain effects\n   * \n   * @public\n   * @korean 고통효과적용\n   */\n  applyEffects(\n    player: PlayerState,\n    shockEffect?: ShockPainEffect\n  ): PlayerState {\n    const level = this.getPainLevel(player.pain);\n    const effects = this.getEffects(level);\n\n    // Calculate total penalties (base pain + shock pain if active)\n    let totalAccuracyPenalty = effects.accuracyReduction;\n    let totalDamagePenalty = effects.damageReduction;\n\n    // Apply shock pain if still active\n    if (shockEffect) {\n      const elapsed = Date.now() - shockEffect.startTime;\n      if (elapsed < shockEffect.duration) {\n        // Add shock pain intensity to penalties\n        totalAccuracyPenalty = Math.min(\n          1.0,\n          totalAccuracyPenalty + shockEffect.intensity\n        );\n        totalDamagePenalty = Math.min(\n          1.0,\n          totalDamagePenalty + shockEffect.intensity\n        );\n      }\n    }\n\n    return {\n      ...player,\n      attackPower: Math.floor(\n        player.attackPower * (1 - totalDamagePenalty)\n      ),\n      defense: Math.floor(\n        player.defense * (1 - effects.performancePenalty)\n      ),\n      speed: Math.floor(\n        player.speed * (1 - effects.speedReduction)\n      ),\n      technique: Math.floor(\n        player.technique * (1 - totalAccuracyPenalty)\n      ),\n    };\n  }\n\n  /**\n   * Checks if pain overload should trigger stun.\n   * \n   * At pain >80, there's a chance per hit to trigger stun based on pain level.\n   * Pain Overload level has 30% chance to trigger stun.\n   * \n   * @param player - Current player state\n   * @returns True if player should be stunned from pain\n   * \n   * @public\n   * @korean 고통기절확인\n   */\n  shouldTriggerStun(player: PlayerState): boolean {\n    if (player.pain < this.PAIN_OVERLOAD_THRESHOLD) {\n      return false;\n    }\n\n    const level = this.getPainLevel(player.pain);\n    const effects = this.getEffects(level);\n\n    // Roll for stun chance\n    return Math.random() < effects.stunChance;\n  }\n\n  /**\n   * Checks if player is in pain overload state (>80 pain).\n   * \n   * @param player - Current player state\n   * @returns True if pain is above overload threshold\n   * \n   * @public\n   * @korean 고통과부하확인\n   */\n  isInPainOverload(player: PlayerState): boolean {\n    return player.pain >= this.PAIN_OVERLOAD_THRESHOLD;\n  }\n\n  /**\n   * Checks if player is incapacitated by pain.\n   * \n   * @param player - Current player state\n   * @returns True if pain is at overload level\n   * \n   * @public\n   * @korean 고통무력화확인\n   */\n  isIncapacitated(player: PlayerState): boolean {\n    return this.getPainLevel(player.pain) === PainLevel.OVERLOAD;\n  }\n\n  /**\n   * Gets bilingual name for pain level.\n   * \n   * @param level - Pain level\n   * @returns Korean and English level names\n   * \n   * @public\n   * @korean 고통이름\n   */\n  getLevelName(level: PainLevel): { korean: string; english: string } {\n    const names: Record<PainLevel, { korean: string; english: string }> = {\n      [PainLevel.MINIMAL]: {\n        korean: \"최소\",\n        english: \"Minimal\",\n      },\n      [PainLevel.MODERATE]: {\n        korean: \"보통\",\n        english: \"Moderate\",\n      },\n      [PainLevel.SIGNIFICANT]: {\n        korean: \"상당\",\n        english: \"Significant\",\n      },\n      [PainLevel.SEVERE]: {\n        korean: \"심각\",\n        english: \"Severe\",\n      },\n      [PainLevel.OVERLOAD]: {\n        korean: \"과부하\",\n        english: \"Overload\",\n      },\n    };\n\n    return names[level];\n  }\n\n  /**\n   * Gets description of pain level effects.\n   * \n   * @param level - Pain level\n   * @returns Bilingual description\n   * \n   * @public\n   * @korean 고통설명\n   */\n  getLevelDescription(level: PainLevel): {\n    korean: string;\n    english: string;\n  } {\n    const descriptions: Record<\n      PainLevel,\n      { korean: string; english: string }\n    > = {\n      [PainLevel.MINIMAL]: {\n        korean: \"최소한의 고통, 전투 능력에 영향 없음\",\n        english: \"Minimal pain, no significant effects on combat\",\n      },\n      [PainLevel.MODERATE]: {\n        korean: \"보통 고통, 약간의 능력 저하 (-10%)\",\n        english: \"Moderate pain, slight performance reduction (-10%)\",\n      },\n      [PainLevel.SIGNIFICANT]: {\n        korean: \"상당한 고통, 명확한 손상 (-20%)\",\n        english: \"Significant pain, noticeable impairment (-20%)\",\n      },\n      [PainLevel.SEVERE]: {\n        korean: \"심각한 고통, 주요 제한 (-35%)\",\n        english: \"Severe pain, major limitations (-35%)\",\n      },\n      [PainLevel.OVERLOAD]: {\n        korean: \"고통 과부하, 기절 위험 (-50%, 30% 기절 확률)\",\n        english: \"Pain overload, stun risk (-50%, 30% stun chance)\",\n      },\n    };\n\n    return descriptions[level];\n  }\n}\n\nexport default PainResponseSystem;\n"],"mappings":"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"}

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

@@ -0,0 +1,123 @@
+/**
+ * SlowMotionController.ts
+ *
+ * Slow-motion time dilation system for Li (Fire) trigram precision strikes.
+ * Triggers dramatic slow-motion effects on vital point hits with camera zoom.
+ *
+ * Features:
+ * - Time dilation (0.3x speed for 1-2 seconds)
+ * - Smooth camera zoom to focus on vital point impact
+ * - Easing functions for smooth transitions
+ * - Integration with Three.js animation loop
+ * - State management for slow-motion phases
+ *
+ * Performance: <0.1ms overhead per frame, no GC pressure
+ *
+ * @module systems/combat/SlowMotionController
+ * @korean 슬로우모션컨트롤러
+ */
+import * as THREE from "three";
+/**
+ * Slow-motion effect configuration
+ */
+export interface SlowMotionConfig {
+    /** Time dilation factor (0.0 = stopped, 1.0 = normal speed) */
+    readonly timeDilation: number;
+    /** Duration of slow-motion effect in seconds */
+    readonly duration: number;
+    /** Camera zoom multiplier (>1.0 = zoom in) */
+    readonly cameraZoom: number;
+    /** Focal point for camera zoom [x, y, z] */
+    readonly focusPoint: readonly [number, number, number];
+}
+/**
+ * Slow-motion effect state
+ */
+export interface SlowMotionState {
+    /** Whether slow-motion is currently active */
+    readonly active: boolean;
+    /** Current time dilation factor */
+    readonly currentTimeDilation: number;
+    /** Elapsed time since effect started (seconds) */
+    readonly elapsed: number;
+    /** Total duration of effect (seconds) */
+    readonly duration: number;
+    /** Camera zoom progress (0.0 to 1.0) */
+    readonly zoomProgress: number;
+}
+/**
+ * SlowMotionController Class
+ *
+ * Manages time dilation and camera effects for precision strike slow-motion
+ */
+export declare class SlowMotionController {
+    private active;
+    private elapsed;
+    private duration;
+    private timeDilation;
+    private currentTimeDilation;
+    private cameraZoom;
+    private focusPoint;
+    private originalCameraPosition;
+    /**
+     * Trigger slow-motion effect
+     *
+     * @param config - Slow-motion configuration
+     */
+    trigger(config: SlowMotionConfig): void;
+    /**
+     * Update slow-motion effect
+     *
+     * Call this in your game loop / useFrame hook
+     *
+     * @param delta - Frame time delta (seconds)
+     * @returns Modified delta accounting for time dilation
+     */
+    update(delta: number): number;
+    /**
+     * Update camera position for zoom effect
+     *
+     * Call this in your game loop after update()
+     *
+     * @param camera - Three.js camera to modify
+     * @param delta - Frame time delta (seconds)
+     */
+    updateCamera(camera: THREE.Camera, delta: number): void;
+    /**
+     * Get current slow-motion state
+     *
+     * @returns Current state
+     */
+    getState(): SlowMotionState;
+    /**
+     * Check if slow-motion is currently active
+     *
+     * @returns True if active
+     */
+    isActive(): boolean;
+    /**
+     * Force stop slow-motion effect
+     */
+    stop(): void;
+    /**
+     * Get current time dilation factor
+     *
+     * @returns Current time dilation (0.0 to 1.0)
+     */
+    getTimeDilation(): number;
+}
+/**
+ * Create a new SlowMotionController instance
+ *
+ * @returns New controller instance
+ */
+export declare function createSlowMotionController(): SlowMotionController;
+/**
+ * Default slow-motion configuration for Li vital point hits
+ */
+export declare const LI_VITAL_POINT_SLOW_MOTION: SlowMotionConfig;
+/**
+ * Moderate slow-motion configuration for regular precision strikes
+ */
+export declare const LI_PRECISION_SLOW_MOTION: SlowMotionConfig;
+//# sourceMappingURL=SlowMotionController.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SlowMotionController.d.ts","sourceRoot":"","sources":["../../../src/systems/combat/SlowMotionController.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAE/B;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,+DAA+D;IAC/D,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,gDAAgD;IAChD,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,8CAA8C;IAC9C,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,4CAA4C;IAC5C,QAAQ,CAAC,UAAU,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;CACxD;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,8CAA8C;IAC9C,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IACzB,mCAAmC;IACnC,QAAQ,CAAC,mBAAmB,EAAE,MAAM,CAAC;IACrC,kDAAkD;IAClD,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,yCAAyC;IACzC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,wCAAwC;IACxC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;CAC/B;AAkBD;;;;GAIG;AACH,qBAAa,oBAAoB;IAC/B,OAAO,CAAC,MAAM,CAAkB;IAChC,OAAO,CAAC,OAAO,CAAa;IAC5B,OAAO,CAAC,QAAQ,CAAa;IAC7B,OAAO,CAAC,YAAY,CAAe;IACnC,OAAO,CAAC,mBAAmB,CAAe;IAC1C,OAAO,CAAC,UAAU,CAAe;IACjC,OAAO,CAAC,UAAU,CAAsC;IACxD,OAAO,CAAC,sBAAsB,CAA8B;IAE5D;;;;OAIG;IACI,OAAO,CAAC,MAAM,EAAE,gBAAgB,GAAG,IAAI;IAmB9C;;;;;;;OAOG;IACI,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;IA2CpC;;;;;;;OAOG;IACI,YAAY,CAAC,MAAM,EAAE,KAAK,CAAC,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI;IAqD9D;;;;OAIG;IACI,QAAQ,IAAI,eAAe;IAYlC;;;;OAIG;IACI,QAAQ,IAAI,OAAO;IAI1B;;OAEG;IACI,IAAI,IAAI,IAAI;IAOnB;;;;OAIG;IACI,eAAe,IAAI,MAAM;CAGjC;AAED;;;;GAIG;AACH,wBAAgB,0BAA0B,IAAI,oBAAoB,CAEjE;AAED;;GAEG;AACH,eAAO,MAAM,0BAA0B,EAAE,gBAKxC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,wBAAwB,EAAE,gBAKtC,CAAC"}

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

@@ -0,0 +1,89 @@
+import { AnimationType } from "../animation";
+import { CombatSystem } from "../CombatSystem";
+import { PlayerState } from "../player";
+import { KoreanTechnique } from "../vitalpoint";
+import { TrainingCombatResult } from "./types";
+/**
+ * Animation context for timing-based hit detection
+ */
+interface AnimationContext {
+    readonly animationType: AnimationType;
+    readonly currentTime: number;
+}
+/**
+ * Training-specific combat system for Korean martial arts practice
+ * Focuses on technique accuracy, form analysis, and educational feedback
+ */
+export declare class TrainingCombatSystem extends CombatSystem {
+    private trainingDummy;
+    private accuracyHistory;
+    private techniqueAttempts;
+    private successfulTechniques;
+    constructor();
+    /**
+     * Create a training dummy with infinite health for practice
+     */
+    private createTrainingDummy;
+    /**
+     * Execute a training technique with detailed analysis
+     * Supports optional animation context for physics-based hit detection
+     */
+    executeTrainingTechnique(player: PlayerState, technique: KoreanTechnique, targetedVitalPointId?: string, animationContext?: AnimationContext): TrainingCombatResult;
+    /**
+     * Calculate accuracy score based on stance, timing, and targeting
+     */
+    private calculateAccuracyScore;
+    /**
+     * Calculate technique execution score
+     */
+    private calculateTechniqueScore;
+    /**
+     * Calculate form score based on balance and positioning
+     */
+    private calculateFormScore;
+    /**
+     * Generate areas for improvement based on scores
+     */
+    private generateImprovementAreas;
+    /**
+     * Generate next training goals
+     */
+    private generateTrainingGoals;
+    /**
+     * Get stance-specific training goals
+     */
+    private getStanceSpecificGoals;
+    /**
+     * Get training statistics
+     */
+    getTrainingStats(): {
+        totalAttempts: number;
+        successfulTechniques: number;
+        successRate: number;
+        overallAccuracy: number;
+        recentAccuracy: number[];
+        improvementTrend: "stable" | "improving" | "declining";
+    };
+    /**
+     * Calculate improvement trend from recent accuracy scores
+     */
+    private calculateImprovementTrend;
+    /**
+     * Reset training session
+     */
+    resetTrainingSession(): void;
+    /**
+     * Fix: Add the missing resetTrainingDummy method that tests expect
+     */
+    resetTrainingDummy(): void;
+    /**
+     * Get training dummy for display
+     */
+    getTrainingDummy(): PlayerState;
+    /**
+     * Update training dummy health (for visual feedback)
+     */
+    updateTrainingDummy(updates: Partial<PlayerState>): void;
+}
+export default TrainingCombatSystem;
+//# sourceMappingURL=TrainingCombatSystem.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"TrainingCombatSystem.d.ts","sourceRoot":"","sources":["../../../src/systems/combat/TrainingCombatSystem.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAC7C,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC/C,OAAO,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AACxC,OAAO,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAE/C;;GAEG;AACH,UAAU,gBAAgB;IACxB,QAAQ,CAAC,aAAa,EAAE,aAAa,CAAC;IACtC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;CAC9B;AAED;;;GAGG;AACH,qBAAa,oBAAqB,SAAQ,YAAY;IACpD,OAAO,CAAC,aAAa,CAAc;IACnC,OAAO,CAAC,eAAe,CAAgB;IACvC,OAAO,CAAC,iBAAiB,CAAa;IACtC,OAAO,CAAC,oBAAoB,CAAa;;IAOzC;;OAEG;IACH,OAAO,CAAC,mBAAmB;IA2C3B;;;OAGG;IACH,wBAAwB,CACtB,MAAM,EAAE,WAAW,EACnB,SAAS,EAAE,eAAe,EAC1B,oBAAoB,CAAC,EAAE,MAAM,EAC7B,gBAAgB,CAAC,EAAE,gBAAgB,GAClC,oBAAoB;IAiDvB;;OAEG;IACH,OAAO,CAAC,sBAAsB;IAY9B;;OAEG;IACH,OAAO,CAAC,uBAAuB;IAgB/B;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAU1B;;OAEG;IACH,OAAO,CAAC,wBAAwB;IAoChC;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAuB7B;;OAEG;IACH,OAAO,CAAC,sBAAsB;IAiB9B;;OAEG;IACH,gBAAgB;;;;;;;;IAsBhB;;OAEG;IACH,OAAO,CAAC,yBAAyB;IAkBjC;;OAEG;IACH,oBAAoB;IAOpB;;OAEG;IACH,kBAAkB;IAIlB;;OAEG;IACH,gBAAgB,IAAI,WAAW;IAI/B;;OAEG;IACH,mBAAmB,CAAC,OAAO,EAAE,OAAO,CAAC,WAAW,CAAC;CAQlD;AAED,eAAe,oBAAoB,CAAC"}