blacktrigram 0.7.2

package/lib/systems/VitalPointSystem.js

@@ -0,0 +1,455 @@
+import { PlayerArchetype, TrigramStance, VitalPointSeverity } from "../types/common.js";
+import VITAL_POINTS_DATA from "./vitalpoint/VitalPointsData.js";
+import { convertToStatusEffect } from "./EffectCalculator.js";
+import { getMeridiansForVitalPoint } from "./vitalpoint/MeridianVitalPointMapping.js";
+import { calculateEnhancedVulnerability, calculateMeridianFlow, generateMeridianEffects } from "./vitalpoint/KoreanAnatomy.js";
+//#region src/systems/VitalPointSystem.ts
+/**
+* System for managing Korean martial arts vital point (급소) targeting and damage calculation.
+*
+* **Korean**: 급소 시스템 (Vital Point System)
+*
+* The VitalPointSystem implements anatomical targeting mechanics based on traditional
+* Korean martial arts knowledge of 70 vital points (급소). It handles hit detection,
+* damage calculation, and status effect application for precise strikes.
+*
+* ## Vital Point Philosophy
+*
+* Korean martial arts identify specific anatomical locations that, when struck precisely,
+* can cause disproportionate effects. The system categorizes points by:
+*
+* - **Location**: Head, neck, torso, limbs, and core
+* - **Category**: Neurological, vascular, respiratory, muscular, skeletal, etc.
+* - **Severity**: Minor, moderate, major, critical, lethal
+* - **Effects**: Unconsciousness, paralysis, pain, stunning, etc.
+*
+* ## Meridian Integration (경락 통합)
+*
+* The system integrates Traditional Korean Medicine (TKM) meridian theory:
+* - **Time-of-Day Flow**: +30% effectiveness at meridian peak hours
+* - **Meridian Disruption**: Status effects from energy flow blockage
+* - **Elemental Relationships**: 五行 (Wu Xing) elemental advantages
+*
+* ## Key Features
+*
+* - Distance-based hit detection with accuracy falloff
+* - Severity multipliers for damage calculation
+* - Targeted vs. proximity-based strikes
+* - Bilingual Korean-English vital point names
+* - Realistic anatomical positioning
+* - Meridian state tracking and flow calculation
+*
+* @example
+* ```typescript
+* const vitalPointSystem = new VitalPointSystem();
+*
+* // Process a strike at specific position with time-of-day
+* const result = vitalPointSystem.processHit(
+*   { x: 100, y: 50 }, // Target position
+*   { width: 10, height: 10 }, // Hit box
+*   "GB-20", // Optional: target specific vital point
+*   14 // Optional: hour of day for meridian flow
+* );
+*
+* if (result.hit && result.vitalPointHit) {
+*   console.log(`Hit ${result.vitalPointHit.names.english}!`);
+*   console.log(`Damage: ${result.damage}, Severity: ${result.severity}`);
+*   console.log(`Meridian bonus: ${result.meridianMultiplier}x`);
+* }
+* ```
+*
+* @public
+* @category Vital Point System
+* @korean 급소시스템
+*/
+/**
+* Amount of meridian disruption added per vital point hit (15%)
+*/
+var DISRUPTION_INCREMENT_PER_HIT = .15;
+var VitalPointSystem = class {
+	vitalPoints = [];
+	meridianStates = /* @__PURE__ */ new Map();
+	currentHour = 12;
+	/**
+	* Creates a new VitalPointSystem instance.
+	*
+	* Initializes the system with comprehensive Korean vital points database
+	* and meridian state tracking.
+	*
+	* @param initialHour - Optional initial hour of day (0-23) for meridian flow calculations
+	*/
+	constructor(initialHour = 12) {
+		this.initializeVitalPoints();
+		this.currentHour = initialHour;
+	}
+	/**
+	* Sets the current hour of day for meridian flow calculations.
+	*
+	* **Korean**: 시간 설정
+	*
+	* @param hour - Hour of day (0-23)
+	* @throws Error if hour is not a finite number
+	*
+	* @example
+	* ```typescript
+	* vitalPointSystem.setCurrentHour(20); // 8 PM - Pericardium peak time
+	* ```
+	*
+	* @public
+	* @korean 시간설정
+	*/
+	setCurrentHour(hour) {
+		if (!Number.isFinite(hour)) throw new Error("Hour must be a finite number");
+		this.currentHour = Math.max(0, Math.min(23, Math.floor(hour)));
+	}
+	/**
+	* Gets the current hour of day used for meridian calculations.
+	*
+	* **Korean**: 현재 시간 조회
+	*
+	* @returns Current hour (0-23)
+	*
+	* @public
+	* @korean 시간조회
+	*/
+	getCurrentHour() {
+		return this.currentHour;
+	}
+	/**
+	* Updates meridian disruption state for a specific meridian.
+	*
+	* **Korean**: 경락 차단 상태 업데이트
+	*
+	* @param meridianId - ID of the meridian
+	* @param disruptionLevel - Disruption level (0-1, where 1 is fully blocked)
+	*
+	* @public
+	* @korean 경락차단업데이트
+	*/
+	setMeridianDisruption(meridianId, disruptionLevel) {
+		this.meridianStates.set(meridianId, Math.max(0, Math.min(1, disruptionLevel)));
+	}
+	/**
+	* Gets the current disruption level for a meridian.
+	*
+	* **Korean**: 경락 차단 수준 조회
+	*
+	* @param meridianId - ID of the meridian
+	* @returns Disruption level (0-1)
+	*
+	* @public
+	* @korean 경락차단조회
+	*/
+	getMeridianDisruption(meridianId) {
+		return this.meridianStates.get(meridianId) ?? 0;
+	}
+	/**
+	* Clears all meridian disruption states (e.g., after rest or healing).
+	*
+	* **Korean**: 경락 상태 초기화
+	*
+	* @public
+	* @korean 경락초기화
+	*/
+	clearMeridianDisruptions() {
+		this.meridianStates.clear();
+	}
+	/**
+	* Processes a hit at a specific position to determine vital point impact.
+	*
+	* Evaluates whether a strike lands on or near a vital point, calculating
+	* damage and effects based on accuracy, severity, and meridian flow.
+	* Supports both targeted strikes (specific vital point ID) and proximity-based detection.
+	*
+	* Enhanced with archetype-specific modifiers for realistic combat simulation.
+	*
+	* ## Hit Detection Algorithm
+	*
+	* 1. If targetedVitalPointId provided, validate that specific point
+	* 2. Otherwise, find closest vital point to target position
+	* 3. Calculate distance from strike to vital point
+	* 4. Apply accuracy falloff based on distance (max 50px)
+	* 5. Calculate meridian flow bonus based on time of day
+	* 6. Apply meridian disruption if applicable
+	* 7. Apply archetype offensive/defensive modifiers
+	* 8. Apply enhanced vulnerability with stance and anatomical zone
+	* 9. Return hit result with damage multipliers and effects
+	*
+	* @param targetPosition - Position where strike lands
+	* @param _hitBox - Size of hit box (currently unused, reserved for future)
+	* @param targetedVitalPointId - Optional specific vital point being targeted
+	* @param hour - Optional hour of day (0-23) for meridian flow calculation
+	* @param attackerArchetype - Optional attacker's archetype (default: MUSA)
+	* @param defenderArchetype - Optional defender's archetype (default: MUSA)
+	* @param defenderStance - Optional defender's trigram stance (default: GEON)
+	* @returns Hit result with damage, effects, severity, and meridian multiplier
+	*
+	* @example
+	* ```typescript
+	* // Proximity-based strike
+	* const result1 = vitalPointSystem.processHit(
+	*   { x: 100, y: 50 },
+	*   { width: 10, height: 10 }
+	* );
+	*
+	* // Targeted strike with archetype modifiers and stance
+	* const result2 = vitalPointSystem.processHit(
+	*   { x: 100, y: 50 },
+	*   { width: 10, height: 10 },
+	*   "head_temple",
+	*   2, // Liver meridian peak hour
+	*   PlayerArchetype.AMSALJA, // Assassin attacker (+30% effect)
+	*   PlayerArchetype.MUSA, // Warrior defender (+20% resistance)
+	*   TrigramStance.GEON // Heaven stance (exposes head +20%)
+	* );
+	* ```
+	*
+	* @public
+	* @korean 타격처리
+	*/
+	processHit(targetPosition, _hitBox, targetedVitalPointId, hour, attackerArchetype, defenderArchetype, defenderStance) {
+		const effectiveHour = hour ?? this.currentHour;
+		const effectiveAttackerArchetype = attackerArchetype ?? PlayerArchetype.MUSA;
+		const effectiveDefenderArchetype = defenderArchetype ?? PlayerArchetype.MUSA;
+		const effectiveDefenderStance = defenderStance ?? TrigramStance.GEON;
+		if (targetedVitalPointId) {
+			const targetVitalPoint = this.getVitalPointById(targetedVitalPointId);
+			if (targetVitalPoint) return this.calculateVitalPointHit(targetVitalPoint, targetPosition, effectiveHour, effectiveAttackerArchetype, effectiveDefenderArchetype, effectiveDefenderStance);
+		}
+		const closestVitalPoint = this.findClosestVitalPoint(targetPosition);
+		if (!closestVitalPoint) return {
+			hit: false,
+			damage: 0,
+			effects: [],
+			severity: VitalPointSeverity.MINOR
+		};
+		if (this.calculateDistance(targetPosition, closestVitalPoint.position) <= 50) return this.calculateVitalPointHit(closestVitalPoint, targetPosition, effectiveHour, effectiveAttackerArchetype, effectiveDefenderArchetype, effectiveDefenderStance);
+		return {
+			hit: false,
+			damage: 0,
+			effects: [],
+			severity: VitalPointSeverity.MINOR
+		};
+	}
+	/**
+	* Retrieves a vital point by its unique identifier.
+	*
+	* @param id - Vital point identifier (e.g., "GB-20", "head_temple")
+	* @returns Vital point if found, null otherwise
+	*
+	* @example
+	* ```typescript
+	* const temple = vitalPointSystem.getVitalPointById("head_temple");
+	* if (temple) {
+	*   console.log(temple.names.korean); // "태양혈"
+	* }
+	* ```
+	*
+	* @public
+	* @korean 급소조회
+	*/
+	getVitalPointById(id) {
+		return this.vitalPoints.find((vp) => vp.id === id) ?? null;
+	}
+	/**
+	* Gets all registered vital points in the system.
+	*
+	* @returns Read-only array of all vital points
+	*
+	* @example
+	* ```typescript
+	* const allPoints = vitalPointSystem.getVitalPoints();
+	* console.log(`${allPoints.length} vital points registered`);
+	* ```
+	*
+	* @public
+	* @korean 급소목록조회
+	*/
+	getVitalPoints() {
+		return this.vitalPoints;
+	}
+	/**
+	* Calculates hit result for a technique-based attack.
+	*
+	* Determines whether a technique successfully lands on a vital point,
+	* factoring in technique accuracy, attacker position, and randomness.
+	* Used for AI and player technique execution.
+	*
+	* @param technique - Technique being executed with accuracy property
+	* @param attackerPosition - Position where attack originates
+	* @param _defenderPosition - Defender position (reserved for future use)
+	* @param _defenderStance - Defender stance (reserved for future use)
+	* @returns Hit result with damage and effects
+	*
+	* @example
+	* ```typescript
+	* const technique = {
+	*   id: "geon-thunder-strike",
+	*   accuracy: 0.85
+	* };
+	*
+	* const result = vitalPointSystem.calculateHit(
+	*   technique,
+	*   { x: 100, y: 50 },
+	*   { x: 120, y: 50 },
+	*   TrigramStance.GEON
+	* );
+	* ```
+	*
+	* @public
+	* @korean 기술타격계산
+	*/
+	calculateHit(technique, attackerPosition, _defenderPosition, _defenderStance) {
+		const closestVitalPoint = this.findClosestVitalPoint(attackerPosition);
+		if (!closestVitalPoint) return {
+			hit: false,
+			damage: 0,
+			effects: [],
+			severity: VitalPointSeverity.MINOR
+		};
+		const distance = this.calculateDistance(attackerPosition, closestVitalPoint.position);
+		const hitChance = technique.accuracy * (1 - distance / 100);
+		if (Math.random() < hitChance) return {
+			hit: true,
+			vitalPointHit: closestVitalPoint,
+			damage: this.calculateBaseDamage(closestVitalPoint, distance),
+			effects: [],
+			severity: closestVitalPoint.severity
+		};
+		return {
+			hit: false,
+			damage: 0,
+			effects: [],
+			severity: VitalPointSeverity.MINOR
+		};
+	}
+	/**
+	* Finds the closest vital point to a given position.
+	*
+	* Uses Euclidean distance to determine proximity.
+	*
+	* @param position - Target position
+	* @returns Closest vital point or null if none registered
+	*
+	* @private
+	* @korean 최근접급소검색
+	*/
+	findClosestVitalPoint(position) {
+		if (this.vitalPoints.length === 0) return null;
+		let closest = this.vitalPoints[0];
+		let minDistance = this.calculateDistance(position, closest.position);
+		for (const vitalPoint of this.vitalPoints) {
+			const distance = this.calculateDistance(position, vitalPoint.position);
+			if (distance < minDistance) {
+				minDistance = distance;
+				closest = vitalPoint;
+			}
+		}
+		return closest;
+	}
+	/**
+	* Calculates Euclidean distance between two positions.
+	*
+	* @param pos1 - First position
+	* @param pos2 - Second position
+	* @returns Distance in pixels
+	*
+	* @private
+	* @korean 거리계산
+	*/
+	calculateDistance(pos1, pos2) {
+		const dx = pos1.x - pos2.x;
+		const dy = pos1.y - pos2.y;
+		return Math.sqrt(dx * dx + dy * dy);
+	}
+	/**
+	* Calculates vital point hit result with accuracy, damage, and meridian effects.
+	*
+	* **Korean**: 급소타격결과계산
+	*
+	* Enhanced with comprehensive effect calculation including:
+	* - Duration based on accuracy, severity, and archetype modifiers
+	* - Intensity scaling with hit accuracy
+	* - Critical hit bonuses for accuracy >= 0.9
+	* - Archetype offensive/defensive modifiers
+	*
+	* @param vitalPoint - Vital point being struck
+	* @param hitPosition - Exact position of strike
+	* @param hour - Hour of day for meridian flow calculation
+	* @param attackerArchetype - Attacker's archetype (default: MUSA)
+	* @param defenderArchetype - Defender's archetype (default: MUSA)
+	* @returns Hit result with calculated damage, accuracy, and meridian bonuses
+	*
+	* @private
+	* @korean 급소타격결과계산
+	*/
+	calculateVitalPointHit(vitalPoint, hitPosition, hour, attackerArchetype = PlayerArchetype.MUSA, defenderArchetype = PlayerArchetype.MUSA, defenderStance = TrigramStance.GEON) {
+		const distance = this.calculateDistance(hitPosition, vitalPoint.position);
+		const baseDamage = this.calculateBaseDamage(vitalPoint, distance);
+		const now = Date.now();
+		const accuracy = Math.max(0, 1 - distance / 50);
+		const meridians = getMeridiansForVitalPoint(vitalPoint.id);
+		let meridianMultiplier = 1;
+		const allMeridianEffects = [];
+		if (meridians.length > 0) {
+			meridianMultiplier = Math.max(...meridians.map((meridianId) => calculateMeridianFlow(meridianId, hour)));
+			meridians.forEach((meridianId) => {
+				const currentDisruption = this.getMeridianDisruption(meridianId);
+				const newDisruption = Math.min(1, currentDisruption + DISRUPTION_INCREMENT_PER_HIT);
+				this.setMeridianDisruption(meridianId, newDisruption);
+				const effects = generateMeridianEffects(meridianId, newDisruption, now);
+				allMeridianEffects.push(...effects);
+			});
+		}
+		const meridianStates = {};
+		meridians.forEach((meridianId) => {
+			meridianStates[meridianId] = 1 - this.getMeridianDisruption(meridianId);
+		});
+		const vulnerabilityMultiplier = calculateEnhancedVulnerability(vitalPoint.position, hour, defenderStance, meridianStates);
+		return {
+			hit: true,
+			vitalPointHit: vitalPoint,
+			damage: Math.floor(baseDamage * meridianMultiplier * vulnerabilityMultiplier),
+			effects: [...vitalPoint.effects.map((effect) => convertToStatusEffect(effect, accuracy, vitalPoint.severity, attackerArchetype, defenderArchetype, vitalPoint.id, now)), ...allMeridianEffects],
+			severity: vitalPoint.severity,
+			accuracy,
+			meridianMultiplier,
+			meridianEffects: allMeridianEffects,
+			multiplier: vulnerabilityMultiplier
+		};
+	}
+	/**
+	* Calculates base damage for a vital point strike.
+	*
+	* Applies distance-based falloff to vital point's base damage value.
+	* Closer strikes deal more damage up to maximum base damage.
+	*
+	* @param vitalPoint - Vital point with base damage property
+	* @param distance - Distance from strike to vital point center
+	* @returns Calculated damage value
+	*
+	* @private
+	* @korean 기본피해계산
+	*/
+	calculateBaseDamage(vitalPoint, distance) {
+		const baseDamage = vitalPoint.baseDamage ?? 10;
+		const distanceModifier = Math.max(.1, 1 - distance / 100);
+		return Math.floor(baseDamage * distanceModifier);
+	}
+	/**
+	* Initializes the system with comprehensive Korean vital points.
+	*
+	* Loads all 70 Korean vital points from the comprehensive database
+	* covering head, torso, arms, and legs with proper categorization.
+	*
+	* @private
+	* @korean 급소초기화
+	*/
+	initializeVitalPoints() {
+		this.vitalPoints = [...VITAL_POINTS_DATA];
+	}
+};
+//#endregion
+export { VitalPointSystem as default };
+
+//# sourceMappingURL=VitalPointSystem.js.map

package/lib/systems/VitalPointSystem.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"VitalPointSystem.js","names":[],"sources":["../../src/systems/VitalPointSystem.ts"],"sourcesContent":["/**\n * System for managing Korean martial arts vital point (급소) targeting and damage calculation.\n *\n * **Korean**: 급소 시스템 (Vital Point System)\n *\n * The VitalPointSystem implements anatomical targeting mechanics based on traditional\n * Korean martial arts knowledge of 70 vital points (급소). It handles hit detection,\n * damage calculation, and status effect application for precise strikes.\n *\n * ## Vital Point Philosophy\n *\n * Korean martial arts identify specific anatomical locations that, when struck precisely,\n * can cause disproportionate effects. The system categorizes points by:\n *\n * - **Location**: Head, neck, torso, limbs, and core\n * - **Category**: Neurological, vascular, respiratory, muscular, skeletal, etc.\n * - **Severity**: Minor, moderate, major, critical, lethal\n * - **Effects**: Unconsciousness, paralysis, pain, stunning, etc.\n *\n * ## Meridian Integration (경락 통합)\n *\n * The system integrates Traditional Korean Medicine (TKM) meridian theory:\n * - **Time-of-Day Flow**: +30% effectiveness at meridian peak hours\n * - **Meridian Disruption**: Status effects from energy flow blockage\n * - **Elemental Relationships**: 五行 (Wu Xing) elemental advantages\n *\n * ## Key Features\n *\n * - Distance-based hit detection with accuracy falloff\n * - Severity multipliers for damage calculation\n * - Targeted vs. proximity-based strikes\n * - Bilingual Korean-English vital point names\n * - Realistic anatomical positioning\n * - Meridian state tracking and flow calculation\n *\n * @example\n * ```typescript\n * const vitalPointSystem = new VitalPointSystem();\n *\n * // Process a strike at specific position with time-of-day\n * const result = vitalPointSystem.processHit(\n *   { x: 100, y: 50 }, // Target position\n *   { width: 10, height: 10 }, // Hit box\n *   \"GB-20\", // Optional: target specific vital point\n *   14 // Optional: hour of day for meridian flow\n * );\n *\n * if (result.hit && result.vitalPointHit) {\n *   console.log(`Hit ${result.vitalPointHit.names.english}!`);\n *   console.log(`Damage: ${result.damage}, Severity: ${result.severity}`);\n *   console.log(`Meridian bonus: ${result.meridianMultiplier}x`);\n * }\n * ```\n *\n * @public\n * @category Vital Point System\n * @korean 급소시스템\n */\nimport {\n  PlayerArchetype,\n  Position,\n  TrigramStance,\n  VitalPointSeverity,\n} from \"../types/common\";\nimport { convertToStatusEffect } from \"./EffectCalculator\";\nimport { StatusEffect } from \"./types\";\nimport {\n  calculateEnhancedVulnerability,\n  calculateMeridianFlow,\n  generateMeridianEffects,\n} from \"./vitalpoint/KoreanAnatomy\";\nimport { getMeridiansForVitalPoint } from \"./vitalpoint/MeridianVitalPointMapping\";\nimport { VitalPoint, VitalPointHitResult } from \"./vitalpoint/types\";\nimport { VITAL_POINTS_DATA } from \"./vitalpoint/VitalPointsData\";\n\n/**\n * Amount of meridian disruption added per vital point hit (15%)\n */\nconst DISRUPTION_INCREMENT_PER_HIT = 0.15;\n\nexport class VitalPointSystem {\n  private vitalPoints: VitalPoint[] = [];\n  private meridianStates: Map<string, number> = new Map(); // Tracks disruption level per meridian\n  private currentHour: number = 12; // Default to noon\n\n  /**\n   * Creates a new VitalPointSystem instance.\n   *\n   * Initializes the system with comprehensive Korean vital points database\n   * and meridian state tracking.\n   *\n   * @param initialHour - Optional initial hour of day (0-23) for meridian flow calculations\n   */\n  constructor(initialHour: number = 12) {\n    // Initialize with comprehensive Korean vital points database\n    this.initializeVitalPoints();\n    this.currentHour = initialHour;\n  }\n\n  /**\n   * Sets the current hour of day for meridian flow calculations.\n   *\n   * **Korean**: 시간 설정\n   *\n   * @param hour - Hour of day (0-23)\n   * @throws Error if hour is not a finite number\n   *\n   * @example\n   * ```typescript\n   * vitalPointSystem.setCurrentHour(20); // 8 PM - Pericardium peak time\n   * ```\n   *\n   * @public\n   * @korean 시간설정\n   */\n  setCurrentHour(hour: number): void {\n    if (!Number.isFinite(hour)) {\n      throw new Error(\"Hour must be a finite number\");\n    }\n    this.currentHour = Math.max(0, Math.min(23, Math.floor(hour)));\n  }\n\n  /**\n   * Gets the current hour of day used for meridian calculations.\n   *\n   * **Korean**: 현재 시간 조회\n   *\n   * @returns Current hour (0-23)\n   *\n   * @public\n   * @korean 시간조회\n   */\n  getCurrentHour(): number {\n    return this.currentHour;\n  }\n\n  /**\n   * Updates meridian disruption state for a specific meridian.\n   *\n   * **Korean**: 경락 차단 상태 업데이트\n   *\n   * @param meridianId - ID of the meridian\n   * @param disruptionLevel - Disruption level (0-1, where 1 is fully blocked)\n   *\n   * @public\n   * @korean 경락차단업데이트\n   */\n  setMeridianDisruption(meridianId: string, disruptionLevel: number): void {\n    this.meridianStates.set(\n      meridianId,\n      Math.max(0, Math.min(1, disruptionLevel)),\n    );\n  }\n\n  /**\n   * Gets the current disruption level for a meridian.\n   *\n   * **Korean**: 경락 차단 수준 조회\n   *\n   * @param meridianId - ID of the meridian\n   * @returns Disruption level (0-1)\n   *\n   * @public\n   * @korean 경락차단조회\n   */\n  getMeridianDisruption(meridianId: string): number {\n    return this.meridianStates.get(meridianId) ?? 0;\n  }\n\n  /**\n   * Clears all meridian disruption states (e.g., after rest or healing).\n   *\n   * **Korean**: 경락 상태 초기화\n   *\n   * @public\n   * @korean 경락초기화\n   */\n  clearMeridianDisruptions(): void {\n    this.meridianStates.clear();\n  }\n\n  /**\n   * Processes a hit at a specific position to determine vital point impact.\n   *\n   * Evaluates whether a strike lands on or near a vital point, calculating\n   * damage and effects based on accuracy, severity, and meridian flow.\n   * Supports both targeted strikes (specific vital point ID) and proximity-based detection.\n   *\n   * Enhanced with archetype-specific modifiers for realistic combat simulation.\n   *\n   * ## Hit Detection Algorithm\n   *\n   * 1. If targetedVitalPointId provided, validate that specific point\n   * 2. Otherwise, find closest vital point to target position\n   * 3. Calculate distance from strike to vital point\n   * 4. Apply accuracy falloff based on distance (max 50px)\n   * 5. Calculate meridian flow bonus based on time of day\n   * 6. Apply meridian disruption if applicable\n   * 7. Apply archetype offensive/defensive modifiers\n   * 8. Apply enhanced vulnerability with stance and anatomical zone\n   * 9. Return hit result with damage multipliers and effects\n   *\n   * @param targetPosition - Position where strike lands\n   * @param _hitBox - Size of hit box (currently unused, reserved for future)\n   * @param targetedVitalPointId - Optional specific vital point being targeted\n   * @param hour - Optional hour of day (0-23) for meridian flow calculation\n   * @param attackerArchetype - Optional attacker's archetype (default: MUSA)\n   * @param defenderArchetype - Optional defender's archetype (default: MUSA)\n   * @param defenderStance - Optional defender's trigram stance (default: GEON)\n   * @returns Hit result with damage, effects, severity, and meridian multiplier\n   *\n   * @example\n   * ```typescript\n   * // Proximity-based strike\n   * const result1 = vitalPointSystem.processHit(\n   *   { x: 100, y: 50 },\n   *   { width: 10, height: 10 }\n   * );\n   *\n   * // Targeted strike with archetype modifiers and stance\n   * const result2 = vitalPointSystem.processHit(\n   *   { x: 100, y: 50 },\n   *   { width: 10, height: 10 },\n   *   \"head_temple\",\n   *   2, // Liver meridian peak hour\n   *   PlayerArchetype.AMSALJA, // Assassin attacker (+30% effect)\n   *   PlayerArchetype.MUSA, // Warrior defender (+20% resistance)\n   *   TrigramStance.GEON // Heaven stance (exposes head +20%)\n   * );\n   * ```\n   *\n   * @public\n   * @korean 타격처리\n   */\n  processHit(\n    targetPosition: Position,\n    _hitBox: { width: number; height: number }, // Prefixed with underscore to indicate intentionally unused\n    targetedVitalPointId?: string | null,\n    hour?: number,\n    attackerArchetype?: PlayerArchetype,\n    defenderArchetype?: PlayerArchetype,\n    defenderStance?: TrigramStance,\n  ): VitalPointHitResult {\n    // Use provided hour or current system hour\n    const effectiveHour = hour ?? this.currentHour;\n    const effectiveAttackerArchetype =\n      attackerArchetype ?? PlayerArchetype.MUSA;\n    const effectiveDefenderArchetype =\n      defenderArchetype ?? PlayerArchetype.MUSA;\n    const effectiveDefenderStance = defenderStance ?? TrigramStance.GEON;\n\n    // If a specific vital point is targeted, check that one\n    if (targetedVitalPointId) {\n      const targetVitalPoint = this.getVitalPointById(targetedVitalPointId);\n      if (targetVitalPoint) {\n        return this.calculateVitalPointHit(\n          targetVitalPoint,\n          targetPosition,\n          effectiveHour,\n          effectiveAttackerArchetype,\n          effectiveDefenderArchetype,\n          effectiveDefenderStance,\n        );\n      }\n    }\n\n    // Otherwise, find the closest vital point\n    const closestVitalPoint = this.findClosestVitalPoint(targetPosition);\n    if (!closestVitalPoint) {\n      return {\n        hit: false,\n        damage: 0,\n        effects: [],\n        severity: VitalPointSeverity.MINOR,\n      };\n    }\n\n    // Calculate distance to determine hit accuracy\n    const distance = this.calculateDistance(\n      targetPosition,\n      closestVitalPoint.position,\n    );\n    const maxHitDistance = 50; // pixels\n\n    if (distance <= maxHitDistance) {\n      return this.calculateVitalPointHit(\n        closestVitalPoint,\n        targetPosition,\n        effectiveHour,\n        effectiveAttackerArchetype,\n        effectiveDefenderArchetype,\n        effectiveDefenderStance,\n      );\n    }\n\n    return {\n      hit: false,\n      damage: 0,\n      effects: [],\n      severity: VitalPointSeverity.MINOR,\n    };\n  }\n\n  /**\n   * Retrieves a vital point by its unique identifier.\n   *\n   * @param id - Vital point identifier (e.g., \"GB-20\", \"head_temple\")\n   * @returns Vital point if found, null otherwise\n   *\n   * @example\n   * ```typescript\n   * const temple = vitalPointSystem.getVitalPointById(\"head_temple\");\n   * if (temple) {\n   *   console.log(temple.names.korean); // \"태양혈\"\n   * }\n   * ```\n   *\n   * @public\n   * @korean 급소조회\n   */\n  getVitalPointById(id: string): VitalPoint | null {\n    return this.vitalPoints.find((vp) => vp.id === id) ?? null;\n  }\n\n  /**\n   * Gets all registered vital points in the system.\n   *\n   * @returns Read-only array of all vital points\n   *\n   * @example\n   * ```typescript\n   * const allPoints = vitalPointSystem.getVitalPoints();\n   * console.log(`${allPoints.length} vital points registered`);\n   * ```\n   *\n   * @public\n   * @korean 급소목록조회\n   */\n  getVitalPoints(): readonly VitalPoint[] {\n    return this.vitalPoints;\n  }\n\n  /**\n   * Calculates hit result for a technique-based attack.\n   *\n   * Determines whether a technique successfully lands on a vital point,\n   * factoring in technique accuracy, attacker position, and randomness.\n   * Used for AI and player technique execution.\n   *\n   * @param technique - Technique being executed with accuracy property\n   * @param attackerPosition - Position where attack originates\n   * @param _defenderPosition - Defender position (reserved for future use)\n   * @param _defenderStance - Defender stance (reserved for future use)\n   * @returns Hit result with damage and effects\n   *\n   * @example\n   * ```typescript\n   * const technique = {\n   *   id: \"geon-thunder-strike\",\n   *   accuracy: 0.85\n   * };\n   *\n   * const result = vitalPointSystem.calculateHit(\n   *   technique,\n   *   { x: 100, y: 50 },\n   *   { x: 120, y: 50 },\n   *   TrigramStance.GEON\n   * );\n   * ```\n   *\n   * @public\n   * @korean 기술타격계산\n   */\n  calculateHit(\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- technique type is dynamically determined by combat system\n    technique: any,\n    attackerPosition: Position,\n    _defenderPosition: Position, // Prefixed with underscore to indicate intentionally unused\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- stance type is dynamically determined by combat system\n    _defenderStance: any, // Prefixed with underscore to indicate intentionally unused\n  ): VitalPointHitResult {\n    // Find closest vital point to attack\n    const closestVitalPoint = this.findClosestVitalPoint(attackerPosition);\n\n    if (!closestVitalPoint) {\n      return {\n        hit: false,\n        damage: 0,\n        effects: [],\n        severity: VitalPointSeverity.MINOR,\n      };\n    }\n\n    // Calculate hit based on technique accuracy and distance\n    const distance = this.calculateDistance(\n      attackerPosition,\n      closestVitalPoint.position,\n    );\n    const hitChance = technique.accuracy * (1 - distance / 100);\n\n    if (Math.random() < hitChance) {\n      return {\n        hit: true,\n        vitalPointHit: closestVitalPoint,\n        damage: this.calculateBaseDamage(closestVitalPoint, distance),\n        effects: [],\n        severity: closestVitalPoint.severity,\n      };\n    }\n\n    return {\n      hit: false,\n      damage: 0,\n      effects: [],\n      severity: VitalPointSeverity.MINOR,\n    };\n  }\n\n  /**\n   * Finds the closest vital point to a given position.\n   *\n   * Uses Euclidean distance to determine proximity.\n   *\n   * @param position - Target position\n   * @returns Closest vital point or null if none registered\n   *\n   * @private\n   * @korean 최근접급소검색\n   */\n  private findClosestVitalPoint(position: Position): VitalPoint | null {\n    if (this.vitalPoints.length === 0) return null;\n\n    let closest = this.vitalPoints[0];\n    let minDistance = this.calculateDistance(position, closest.position);\n\n    for (const vitalPoint of this.vitalPoints) {\n      const distance = this.calculateDistance(position, vitalPoint.position);\n      if (distance < minDistance) {\n        minDistance = distance;\n        closest = vitalPoint;\n      }\n    }\n\n    return closest;\n  }\n\n  /**\n   * Calculates Euclidean distance between two positions.\n   *\n   * @param pos1 - First position\n   * @param pos2 - Second position\n   * @returns Distance in pixels\n   *\n   * @private\n   * @korean 거리계산\n   */\n  private calculateDistance(pos1: Position, pos2: Position): number {\n    const dx = pos1.x - pos2.x;\n    const dy = pos1.y - pos2.y;\n    return Math.sqrt(dx * dx + dy * dy);\n  }\n\n  /**\n   * Calculates vital point hit result with accuracy, damage, and meridian effects.\n   *\n   * **Korean**: 급소타격결과계산\n   *\n   * Enhanced with comprehensive effect calculation including:\n   * - Duration based on accuracy, severity, and archetype modifiers\n   * - Intensity scaling with hit accuracy\n   * - Critical hit bonuses for accuracy >= 0.9\n   * - Archetype offensive/defensive modifiers\n   *\n   * @param vitalPoint - Vital point being struck\n   * @param hitPosition - Exact position of strike\n   * @param hour - Hour of day for meridian flow calculation\n   * @param attackerArchetype - Attacker's archetype (default: MUSA)\n   * @param defenderArchetype - Defender's archetype (default: MUSA)\n   * @returns Hit result with calculated damage, accuracy, and meridian bonuses\n   *\n   * @private\n   * @korean 급소타격결과계산\n   */\n  private calculateVitalPointHit(\n    vitalPoint: VitalPoint,\n    hitPosition: Position,\n    hour: number,\n    attackerArchetype: PlayerArchetype = PlayerArchetype.MUSA,\n    defenderArchetype: PlayerArchetype = PlayerArchetype.MUSA,\n    defenderStance: TrigramStance = TrigramStance.GEON,\n  ): VitalPointHitResult {\n    const distance = this.calculateDistance(hitPosition, vitalPoint.position);\n    const baseDamage = this.calculateBaseDamage(vitalPoint, distance);\n    const now = Date.now(); // Single timestamp for all effects\n\n    // Calculate hit accuracy (0-1 scale based on distance)\n    const accuracy = Math.max(0, 1 - distance / 50);\n\n    // Get meridians for this vital point\n    const meridians = getMeridiansForVitalPoint(vitalPoint.id);\n\n    // Calculate meridian flow effectiveness (highest value if multiple meridians)\n    let meridianMultiplier = 1.0;\n    const allMeridianEffects: StatusEffect[] = [];\n\n    if (meridians.length > 0) {\n      // Use the best meridian flow multiplier\n      meridianMultiplier = Math.max(\n        ...meridians.map((meridianId) =>\n          calculateMeridianFlow(meridianId, hour),\n        ),\n      );\n\n      // Generate meridian disruption effects for each affected meridian\n      meridians.forEach((meridianId) => {\n        const currentDisruption = this.getMeridianDisruption(meridianId);\n        const newDisruption = Math.min(\n          1,\n          currentDisruption + DISRUPTION_INCREMENT_PER_HIT,\n        );\n        this.setMeridianDisruption(meridianId, newDisruption);\n\n        // Generate effects if disruption is significant (using shared timestamp)\n        const effects = generateMeridianEffects(meridianId, newDisruption, now);\n        allMeridianEffects.push(...effects);\n      });\n    }\n\n    // Calculate enhanced vulnerability based on anatomical zone, stance, meridian flow, and time\n    const meridianStates: Record<string, number> = {};\n    meridians.forEach((meridianId) => {\n      // Convert disruption (0=normal, 1=blocked) to flow state (1=normal, 0=blocked)\n      const disruption = this.getMeridianDisruption(meridianId);\n      meridianStates[meridianId] = 1.0 - disruption;\n    });\n\n    const vulnerabilityMultiplier = calculateEnhancedVulnerability(\n      vitalPoint.position,\n      hour,\n      defenderStance,\n      meridianStates,\n    );\n\n    // Apply all multipliers to damage: base × meridian flow × vulnerability\n    const finalDamage = Math.floor(\n      baseDamage * meridianMultiplier * vulnerabilityMultiplier,\n    );\n\n    // Convert VitalPointEffect to StatusEffect with comprehensive calculations\n    const vitalPointStatusEffects: StatusEffect[] = vitalPoint.effects.map(\n      (effect) =>\n        convertToStatusEffect(\n          effect,\n          accuracy,\n          vitalPoint.severity,\n          attackerArchetype,\n          defenderArchetype,\n          vitalPoint.id,\n          now,\n        ),\n    );\n\n    // Combine vital point effects with meridian effects\n    const combinedEffects = [...vitalPointStatusEffects, ...allMeridianEffects];\n\n    return {\n      hit: true,\n      vitalPointHit: vitalPoint,\n      damage: finalDamage,\n      effects: combinedEffects,\n      severity: vitalPoint.severity,\n      accuracy,\n      meridianMultiplier,\n      meridianEffects: allMeridianEffects,\n      multiplier: vulnerabilityMultiplier,\n    };\n  }\n\n  /**\n   * Calculates base damage for a vital point strike.\n   *\n   * Applies distance-based falloff to vital point's base damage value.\n   * Closer strikes deal more damage up to maximum base damage.\n   *\n   * @param vitalPoint - Vital point with base damage property\n   * @param distance - Distance from strike to vital point center\n   * @returns Calculated damage value\n   *\n   * @private\n   * @korean 기본피해계산\n   */\n  private calculateBaseDamage(\n    vitalPoint: VitalPoint,\n    distance: number,\n  ): number {\n    const baseDamage = vitalPoint.baseDamage ?? 10;\n    const distanceModifier = Math.max(0.1, 1 - distance / 100);\n    return Math.floor(baseDamage * distanceModifier);\n  }\n\n  /**\n   * Initializes the system with comprehensive Korean vital points.\n   *\n   * Loads all 70 Korean vital points from the comprehensive database\n   * covering head, torso, arms, and legs with proper categorization.\n   *\n   * @private\n   * @korean 급소초기화\n   */\n  private initializeVitalPoints(): void {\n    // Load all 70 vital points from the comprehensive database\n    this.vitalPoints = [...VITAL_POINTS_DATA];\n  }\n}\n\nexport default VitalPointSystem;\n"],"mappings":"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"}

package/lib/systems/ai/AIPersonality.d.ts

@@ -0,0 +1,133 @@
+/**
+ * AI Personality System for Korean Martial Arts Combat
+ * Defines behavioral archetypes that guide AI decision-making
+ */
+import { PlayerArchetype, TrigramStance } from "../../types";
+/**
+ * Movement pattern types for archetype behavior
+ *
+ * @korean 이동 패턴 타입
+ */
+export type MovementPattern = "aggressive" | "evasive" | "analytical" | "unpredictable";
+/**
+ * Vital target priority for archetype-specific combat strategies
+ *
+ * @korean 급소 우선순위
+ */
+export type VitalTargetPriority = "health" | "pain" | "consciousness" | "balanced";
+/**
+ * Technique category types for archetype preferences
+ *
+ * @korean 기술 범주
+ */
+export type TechniqueCategory = "joint_manipulation" | "bone_strikes" | "nerve_strikes" | "silent_takedowns" | "anatomical_analysis" | "calculated_strikes" | "psychological_pressure" | "submission_induction" | "dirty_techniques" | "environmental_usage";
+/**
+ * Archetype-specific behavior profile
+ *
+ * Defines combat preferences, movement patterns, and tactical decision-making
+ * unique to each of the 5 player archetypes.
+ *
+ * @korean 원형별 행동 프로필
+ */
+export interface ArchetypeBehavior {
+    /** Preferred trigram stances for this archetype */
+    readonly preferredStances: readonly TrigramStance[];
+    /** Optimal combat range in grid cells (1 cell = ~40px) */
+    readonly optimalRange: number;
+    /** Health percentage threshold to trigger retreat behavior */
+    readonly retreatThreshold: number;
+    /** Technique categories this archetype favors */
+    readonly techniqueSelectionBias: readonly TechniqueCategory[];
+    /** Movement pattern characteristic of this archetype */
+    readonly movementPattern: MovementPattern;
+    /** Whether archetype follows honor code (affects retreat behavior) */
+    readonly honorCode: boolean;
+    /** Priority system for vital point targeting */
+    readonly vitalTargetPriority: VitalTargetPriority;
+}
+/**
+ * AI personality profile defining combat behavior
+ */
+export interface AIPersonality {
+    readonly name: string;
+    readonly koreanName: string;
+    readonly archetype: PlayerArchetype;
+    readonly aggressionLevel: number;
+    readonly defensePreference: number;
+    readonly comboTendency: number;
+    readonly stanceSwitchFrequency: number;
+    readonly feintChance: number;
+    readonly tacticalRetreatThreshold: number;
+    readonly favoredStances: readonly TrigramStance[];
+    readonly description: {
+        readonly korean: string;
+        readonly english: string;
+    };
+}
+/**
+ * Archetype-specific behavior profiles
+ *
+ * Maps each of the 5 player archetypes to their unique combat behaviors,
+ * movement patterns, and tactical preferences based on Korean martial arts
+ * traditions and game design philosophy.
+ *
+ * @korean 원형별 행동 프로필
+ */
+export declare const ARCHETYPE_BEHAVIORS: Record<PlayerArchetype, ArchetypeBehavior>;
+/**
+ * Five AI personality archetypes inspired by Korean martial arts philosophy
+ */
+export declare const AI_PERSONALITIES: Record<string, AIPersonality>;
+/**
+ * Get a random AI personality
+ */
+export declare function getRandomPersonality(): AIPersonality;
+/**
+ * Get personality by archetype
+ */
+export declare function getPersonalityByArchetype(archetype: PlayerArchetype): AIPersonality;
+/**
+ * Get personality by name key
+ */
+export declare function getPersonalityByName(name: string): AIPersonality;
+/**
+ * List all available personalities
+ */
+export declare function getAllPersonalities(): readonly AIPersonality[];
+/**
+ * Get archetype-specific behavior profile
+ *
+ * Retrieves the unique combat behavior configuration for a given archetype,
+ * including movement patterns, optimal ranges, and tactical preferences.
+ *
+ * @param archetype - Player archetype to get behavior for
+ * @returns Archetype behavior profile
+ *
+ * @korean 원형별 행동 프로필 가져오기
+ */
+export declare function getArchetypeBehavior(archetype: PlayerArchetype): ArchetypeBehavior;
+/**
+ * Check if archetype follows honor code
+ *
+ * Honor code affects retreat behavior - honor-bound archetypes like Musa
+ * will not retreat above their health threshold.
+ *
+ * @param archetype - Player archetype to check
+ * @returns True if archetype follows honor code
+ *
+ * @korean 명예 규범 확인
+ */
+export declare function followsHonorCode(archetype: PlayerArchetype): boolean;
+/**
+ * Get optimal combat range for archetype
+ *
+ * Returns the preferred distance in grid cells (1 cell = ~40px) where
+ * the archetype is most effective in combat.
+ *
+ * @param archetype - Player archetype
+ * @returns Optimal range in grid cells
+ *
+ * @korean 최적 전투 거리 가져오기
+ */
+export declare function getOptimalRange(archetype: PlayerArchetype): number;
+//# sourceMappingURL=AIPersonality.d.ts.map

package/lib/systems/ai/AIPersonality.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AIPersonality.d.ts","sourceRoot":"","sources":["../../../src/systems/ai/AIPersonality.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAEzD;;;;GAIG;AACH,MAAM,MAAM,eAAe,GACvB,YAAY,GACZ,SAAS,GACT,YAAY,GACZ,eAAe,CAAC;AAEpB;;;;GAIG;AACH,MAAM,MAAM,mBAAmB,GAC3B,QAAQ,GACR,MAAM,GACN,eAAe,GACf,UAAU,CAAC;AAEf;;;;GAIG;AACH,MAAM,MAAM,iBAAiB,GACzB,oBAAoB,GACpB,cAAc,GACd,eAAe,GACf,kBAAkB,GAClB,qBAAqB,GACrB,oBAAoB,GACpB,wBAAwB,GACxB,sBAAsB,GACtB,kBAAkB,GAClB,qBAAqB,CAAC;AAE1B;;;;;;;GAOG;AACH,MAAM,WAAW,iBAAiB;IAChC,mDAAmD;IACnD,QAAQ,CAAC,gBAAgB,EAAE,SAAS,aAAa,EAAE,CAAC;IACpD,0DAA0D;IAC1D,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,8DAA8D;IAC9D,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC,iDAAiD;IACjD,QAAQ,CAAC,sBAAsB,EAAE,SAAS,iBAAiB,EAAE,CAAC;IAC9D,wDAAwD;IACxD,QAAQ,CAAC,eAAe,EAAE,eAAe,CAAC;IAC1C,sEAAsE;IACtE,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B,gDAAgD;IAChD,QAAQ,CAAC,mBAAmB,EAAE,mBAAmB,CAAC;CACnD;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,SAAS,EAAE,eAAe,CAAC;IACpC,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAC;IACnC,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,qBAAqB,EAAE,MAAM,CAAC;IACvC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,wBAAwB,EAAE,MAAM,CAAC;IAC1C,QAAQ,CAAC,cAAc,EAAE,SAAS,aAAa,EAAE,CAAC;IAClD,QAAQ,CAAC,WAAW,EAAE;QACpB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;QACxB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;KAC1B,CAAC;CACH;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,mBAAmB,EAAE,MAAM,CAAC,eAAe,EAAE,iBAAiB,CAkD1E,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CA0J1D,CAAC;AAEF;;GAEG;AACH,wBAAgB,oBAAoB,IAAI,aAAa,CAGpD;AAED;;GAEG;AACH,wBAAgB,yBAAyB,CACvC,SAAS,EAAE,eAAe,GACzB,aAAa,CAKf;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,aAAa,CAEhE;AAED;;GAEG;AACH,wBAAgB,mBAAmB,IAAI,SAAS,aAAa,EAAE,CAE9D;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,oBAAoB,CAClC,SAAS,EAAE,eAAe,GACzB,iBAAiB,CAEnB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,eAAe,GAAG,OAAO,CAEpE;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,CAAC,SAAS,EAAE,eAAe,GAAG,MAAM,CAElE"}