blacktrigram 0.7.2

package/lib/systems/ai/DecisionTree.js

@@ -0,0 +1,1516 @@
+import { PlayerArchetype, TrigramStance } from "../../types/common.js";
+import "../../types/index.js";
+import { AI_MOVEMENT_METERS } from "../../types/physicsConstants.js";
+import { getArchetypePhysicalAttributes } from "../../data/archetypePhysicalAttributes.js";
+import TrigramSystem from "../TrigramSystem.js";
+import { getArchetypeBehavior } from "./AIPersonality.js";
+import KOREAN_VITAL_POINTS, { getVitalPointById } from "../vitalpoint/KoreanVitalPoints.js";
+import { AIActionType } from "./types.js";
+import { enforceArchetypeBehavior } from "./ArchetypeEnforcer.js";
+//#region src/systems/ai/DecisionTree.ts
+/**
+* AI Decision Tree for Korean Martial Arts Combat
+* Strategic decision-making system with multiple tactical options
+*
+* **Korean Philosophy Integration (한국 무술 철학)**:
+* - 지피지기백전불태 (知彼知己百戰不殆) - Know the enemy, know yourself, and victory is certain
+* - 이순응변 (以柔應變) - Adapt with flexibility and flow like water
+* - 급소공격 (急所攻擊) - Strike vital points with precision and timing
+*/
+/**
+* Body pivot contributions for reach calculations (meters)
+* 
+* These values represent additional reach gained from body mechanics:
+* - Hip rotation and torso lean for kicks
+* - Shoulder offset and torso rotation for punches
+* 
+* Heuristically aligned with PhysicalReachCalculator.ts but intentionally
+* simplified for AI decision-making (e.g., omits stance/animation modifiers).
+* 
+* **NOTE ON BODY RADIUS**: The body pivot values approximate the body radius
+* effect for AI range calculations. For precise hit detection in CombatSystem,
+* use calculateBodyRadius() which accounts for individual archetype differences.
+* 
+* AI decision-making trade-off:
+* - Punch body pivot (shoulder offset + torso rotation): ~0.3-0.35m
+* - Actual body radius (shoulder width * 0.5 / 100): ~0.215-0.27m
+* - Difference: AI slightly overestimates close-range effectiveness
+* - Impact: AI may attempt attacks at marginally longer range than optimal
+* - Benefit: Simplified calculations, acceptable gameplay behavior
+* 
+* @korean 신체 회전 도달 거리 증가 (AI 의사결정을 위한 근사치)
+*/
+var BODY_PIVOT_METERS = {
+	KICK: .25,
+	TORSO_ROTATION: .1
+};
+/**
+* Average technique extension multipliers
+* 
+* Based on analysis of technique baseExtension values:
+* - Punches: 0.9-0.95 (average 0.95)
+* - Kicks: 1.0-1.05 (average 1.05)
+* 
+* TODO: Consider implementing technique-specific lookup based on actual
+* technique data for more precise range calculations. Current averages
+* are sufficient for AI decision-making but may need refinement.
+* 
+* @korean 기술 연장 배수
+*/
+var TECHNIQUE_EXTENSION = {
+	PUNCH: .95,
+	KICK: 1.05
+};
+/**
+* Distance-based stance preferences for tactical positioning
+*
+* Stances are categorized by optimal combat range based on actual technique
+* reach configurations (baseExtension values from technique definitions):
+*
+* **CLOSE (≤0.6m)** - Grappling/clinch range:
+* - TAE (☱ Lake) - Joint manipulation, grapples (0.9 baseExtension, needs contact)
+* - GAM (☵ Water) - Throws, counters (0.7-0.9 baseExtension)
+* - GON (☷ Earth) - Ground techniques, Ssireum throws (0.9 baseExtension)
+* - GAN (☶ Mountain) - Immovable defense, blocks (0.9 baseExtension)
+*
+* **MID (0.6-1.0m)** - Striking range:
+* - GEON (☰ Heaven) - Direct force, power strikes (0.95-1.05 baseExtension)
+* - LI (☲ Fire) - Precision nerve strikes (0.92-0.95 baseExtension)
+* - SON (☴ Wind) - Continuous pressure, Taekyon (0.95-1.05 baseExtension)
+*
+* **FAR (>1.0m)** - Long range kicks/closing distance:
+* - JIN (☳ Thunder) - Explosive jumping kicks (1.15 baseExtension)
+* - SON (☴ Wind) - Closing footwork pressure
+* - GAN (☶ Mountain) - Patient defensive waiting
+*
+* @korean 거리별 자세 선호도 (기술 도달 거리 기반)
+*/
+var DISTANCE_BASED_STANCES = {
+	CLOSE: [
+		TrigramStance.TAE,
+		TrigramStance.GAM,
+		TrigramStance.GON,
+		TrigramStance.GAN
+	],
+	MID: [
+		TrigramStance.GEON,
+		TrigramStance.LI,
+		TrigramStance.SON
+	],
+	FAR: [
+		TrigramStance.JIN,
+		TrigramStance.SON,
+		TrigramStance.GAN
+	]
+};
+/**
+* Hacker observation phase duration in milliseconds
+*
+* Hacker archetype observes opponents for this duration before attacking,
+* collecting combat data for analysis-based tactics.
+*
+* @korean 해커 관찰 단계 지속 시간 (밀리초)
+*/
+var HACKER_OBSERVATION_DURATION_MS = 1e4;
+/**
+* Hacker observation phase actions
+*
+* During the observation phase, Hacker only uses non-aggressive
+* positioning actions to collect combat data.
+*
+* @korean 해커 관찰 단계 행동
+*/
+var HACKER_OBSERVATION_ACTIONS = [
+	AIActionType.WAIT,
+	AIActionType.CIRCLE,
+	AIActionType.APPROACH
+];
+/**
+* Assess opponent vulnerability for exploitation tactics
+*
+* Analyzes multiple vulnerability factors to create comprehensive assessment:
+* - Balance states (HELPLESS/VULNERABLE/SHAKEN)
+* - Stamina depletion (< 20%)
+* - Ki depletion (< 10%)
+* - Composite vulnerability score (weighted average)
+*
+* **Korean Philosophy (취약성 평가)**:
+* Traditional Korean martial arts teach reading opponent's weakness:
+* - 기회 포착 (Gihoei Pochak) - Seizing opportunities
+* - 약점 공격 (Yakjeom Gonggyeok) - Exploiting weaknesses
+* - 결정타 (Gyeoljeongta) - Delivering decisive strikes
+*
+* @korean 상대 취약성 평가
+*
+* @param context - Current combat context with opponent state
+* @returns Vulnerability assessment with boolean flags and composite score
+*/
+function assessVulnerability(context) {
+	const isHelpless = context.opponentBalance === "HELPLESS";
+	const isVulnerable = context.opponentBalance === "VULNERABLE" || context.opponentBalance === "HELPLESS";
+	const isShaken = context.opponentBalance === "SHAKEN" || context.opponentBalance === "VULNERABLE" || context.opponentBalance === "HELPLESS";
+	const staminaPercent = context.opponentStamina && context.opponentMaxStamina ? context.opponentStamina / context.opponentMaxStamina : 1;
+	const kiPercent = context.opponentKi && context.opponentMaxKi ? context.opponentKi / context.opponentMaxKi : 1;
+	const hasLowStamina = staminaPercent < .2;
+	const hasNoKi = kiPercent < .1;
+	let balanceVulnerability = 0;
+	if (isHelpless) balanceVulnerability = 1;
+	else if (isVulnerable) balanceVulnerability = .7;
+	else if (isShaken) balanceVulnerability = .5;
+	return {
+		isHelpless,
+		isVulnerable,
+		isShaken,
+		hasLowStamina,
+		hasNoKi,
+		overallVulnerability: balanceVulnerability * .4 + (1 - staminaPercent) * .3 + (1 - kiPercent) * .3
+	};
+}
+/**
+* AI Decision Tree System
+*
+* **Korean Combat Philosophy (한국 무술 철학)**:
+* This system embodies traditional Korean martial arts principles:
+*
+* - **팔괘 응용** (Trigram Application): Uses Eight Trigram system for stance transitions
+* - **급소 타격** (Vital Point Strikes): Targets anatomical weak points with precision
+* - **상황 판단** (Situational Awareness): Adapts tactics based on combat context
+* - **기술 조합** (Technique Combinations): Chains attacks into flowing combos
+* - **방어 우선** (Defense First): Prioritizes survival and tactical retreat when needed
+* - **취약성 공략** (Vulnerability Exploitation): Exploits defenseless states with precision (Issue #enhance-intelligence-operative-ai)
+*/
+var AIDecisionTree = class AIDecisionTree {
+	lastDecisionTime = 0;
+	decisionCooldown = 50;
+	consecutiveAttacks = 0;
+	lastStanceChange = 0;
+	stanceChangeCooldown = 3e3;
+	psychologicalPressure = 0;
+	lastPressureActionTime = 0;
+	trigramSystem;
+	difficultyLevel = .5;
+	difficultyParams;
+	currentReactionDelay = 50;
+	/**
+	* Scaling factor for fatigue override probability calculation.
+	* Used to convert fatigue modifier to override chance in non-linear manner.
+	* Value of 0.5 provides gradual scaling: 1.2x fatigue → ~10% override, 1.5x → ~25%.
+	*
+	* @korean 피로도 우선순위 무시 배율
+	*/
+	static FATIGUE_OVERRIDE_SCALING_FACTOR = .5;
+	constructor() {
+		this.trigramSystem = new TrigramSystem();
+	}
+	/**
+	* Calculate kick reach for an archetype based on physical attributes.
+	* 
+	* **Physics-First**: Returns reach in METERS based on leg length.
+	* Includes realistic kick reach calculation:
+	* - Leg length converted from cm to meters
+	* - Body pivot contribution (hip rotation + torso lean)
+	* - Average baseExtension for kicks (1.05x multiplier)
+	*
+	* Formula: (legLength/100 + BODY_PIVOT_METERS.KICK) × TECHNIQUE_EXTENSION.KICK
+	*
+	* @param archetype - Player archetype to calculate reach for
+	* @returns Kick reach in meters
+	* @korean 발차기 도달 거리 (미터)
+	*/
+	getKickReachMeters(archetype) {
+		return (getArchetypePhysicalAttributes(archetype).legLength / 100 + BODY_PIVOT_METERS.KICK) * TECHNIQUE_EXTENSION.KICK;
+	}
+	/**
+	* Calculate punch reach for an archetype based on physical attributes.
+	* 
+	* **Physics-First**: Returns reach in METERS based on arm length.
+	* Includes realistic punch reach calculation:
+	* - Arm length converted from cm to meters
+	* - Body pivot (shoulder offset + torso rotation)
+	* - Average baseExtension for punches (0.95x multiplier)
+	*
+	* Formula: (armLength/100 + shoulderOffset + torsoRotation) × TECHNIQUE_EXTENSION.PUNCH
+	*
+	* @param archetype - Player archetype to calculate reach for
+	* @returns Punch reach in meters
+	* @korean 주먹 도달 거리 (미터)
+	*/
+	getPunchReachMeters(archetype) {
+		const physical = getArchetypePhysicalAttributes(archetype);
+		const bodyPivot = physical.shoulderWidth / 2 / 100 + BODY_PIVOT_METERS.TORSO_ROTATION;
+		return (physical.armLength / 100 + bodyPivot) * TECHNIQUE_EXTENSION.PUNCH;
+	}
+	/**
+	* Calculate maximum combat reach for an archetype based on physical attributes.
+	*
+	* **Physics-First**: Returns reach in METERS based on leg length.
+	* Kicks have the longest reach (~1.0-1.3m with body pivot contribution).
+	*
+	* Note: This is a heuristic approximation. Actual reach also depends on
+	* stance modifiers and animation timing not included in AI range calculations.
+	*
+	* @param archetype - Player archetype to calculate reach for
+	* @returns Maximum combat reach in meters
+	* @korean 원형별 최대 도달 거리 (미터)
+	*/
+	getArchetypeMaxReach(archetype) {
+		return this.getKickReachMeters(archetype);
+	}
+	/**
+	* Get close range threshold for an archetype (punching/elbow distance).
+	* Based on arm length from physical attributes.
+	* 
+	* Uses the shared punch reach calculation helper for consistency.
+	* 
+	* TODO: Extract to shared utility function with PhysicalReachCalculator.ts
+	* to maintain consistency between AI range calculations and actual hit detection.
+	* Consider handling elbow techniques separately with different body pivot values.
+	*
+	* @param archetype - Player archetype
+	* @returns Close range threshold in meters
+	* @korean 근접 범위 (미터)
+	*/
+	getArchetypeCloseRange(archetype) {
+		return this.getPunchReachMeters(archetype);
+	}
+	/**
+	* Get medium range threshold for an archetype (kicking distance).
+	* Based on leg length from physical attributes.
+	* 
+	* Includes realistic kick reach calculation:
+	* - Leg length converted from cm to meters  
+	* - Body pivot contribution (hip rotation + torso lean)
+	* - Average baseExtension for kicks
+	*
+	* @param archetype - Player archetype
+	* @returns Medium range threshold in meters
+	* @korean 중거리 범위 (미터)
+	*/
+	getArchetypeMediumRange(archetype) {
+		return this.getKickReachMeters(archetype);
+	}
+	/**
+	* Set AI difficulty level for vital point targeting accuracy
+	* @param level - 0.0 (beginner) to 1.0 (master)
+	*/
+	setDifficultyLevel(level) {
+		this.difficultyLevel = Math.max(0, Math.min(1, level));
+	}
+	/**
+	* Set difficulty parameters for AI behavior
+	* Affects reaction time, accuracy, decision quality, etc.
+	*
+	* Calculates a randomized reaction delay (within parameter range) once when
+	* parameters change. This provides varied AI timing while maintaining consistent
+	* behavior throughout the current parameter set.
+	*
+	* @korean 난이도 매개변수 설정
+	* @param params - Difficulty parameters to apply
+	*/
+	setDifficultyParameters(params) {
+		this.difficultyParams = params;
+		if (params) this.currentReactionDelay = params.reactionTimeMs.min + Math.random() * (params.reactionTimeMs.max - params.reactionTimeMs.min);
+	}
+	/**
+	* Check if kill mode should be activated based on archetype behavior
+	*
+	* Kill mode activates when:
+	* - Opponent health is low (<30%)
+	* - Opponent is in vulnerable balance state (HELPLESS/VULNERABLE)
+	*
+	* **Korean Philosophy (결정타 모드)**:
+	* Each archetype activates kill mode differently based on combat philosophy:
+	* - **Musa**: Honor demands finishing the fight decisively
+	* - **Amsalja**: Opportunity for instant takedown with precision
+	* - **Hacker**: Analytical window for calculated strike
+	* - **Jeongbo Yowon**: Strategic opportunity for submission
+	* - **Jojik Pokryeokbae**: Pragmatic moment to finish brutally
+	*
+	* @korean 결정타 모드 활성화 확인
+	*
+	* @param context - Current combat context
+	* @param personality - AI personality archetype
+	* @returns True if kill mode should be active
+	*/
+	isKillModeActive(context, personality) {
+		const opponentHealthPercent = context.opponentHealth / context.playerMaxHealth;
+		const isOpponentVulnerable = context.opponentBalance != null && (context.opponentBalance === "HELPLESS" || context.opponentBalance === "VULNERABLE");
+		let healthThreshold = .3;
+		switch (personality.archetype) {
+			case PlayerArchetype.MUSA:
+				healthThreshold = .3;
+				break;
+			case PlayerArchetype.AMSALJA:
+				healthThreshold = .3;
+				break;
+			case PlayerArchetype.HACKER:
+				healthThreshold = .25;
+				break;
+			case PlayerArchetype.JEONGBO_YOWON:
+				healthThreshold = .28;
+				break;
+			case PlayerArchetype.JOJIK_POKRYEOKBAE:
+				healthThreshold = .35;
+				break;
+		}
+		return opponentHealthPercent < healthThreshold || isOpponentVulnerable;
+	}
+	/**
+	* Apply kill mode modifiers to action weights for finishing behavior
+	*
+	* **Kill Mode Behavior (결정타 행동)**:
+	* Each archetype has unique finishing behavior based on combat philosophy:
+	* - **Musa**: All-in overwhelming force (2.5x attack, 0x retreat)
+	* - **Amsalja**: Instant takedown focus (3.0x technique, feints disabled)
+	* - **Hacker**: Analytical precision (2.0x technique, counter focus)
+	* - **Jeongbo Yowon**: Strategic control (1.8x technique, balanced approach)
+	* - **Jojik Pokryeokbae**: Brutal pragmatism (2.2x attack, dirty tactics)
+	*
+	* @korean 결정타 모드 가중치 적용
+	*
+	* @param baseWeights - Base action weight multipliers
+	* @param personality - AI personality archetype
+	* @param isKillMode - Whether kill mode is active
+	* @returns Modified action weights for kill mode
+	*/
+	applyKillModeModifiers(baseWeights, personality, isKillMode) {
+		if (!isKillMode) return baseWeights;
+		const modified = { ...baseWeights };
+		switch (personality.archetype) {
+			case PlayerArchetype.MUSA:
+				modified.attack *= 2.5;
+				modified.technique *= 2;
+				modified.defend *= .2;
+				modified.retreat = 0;
+				break;
+			case PlayerArchetype.AMSALJA:
+				modified.technique *= 3;
+				modified.attack *= 1.5;
+				modified.defend *= .3;
+				break;
+			case PlayerArchetype.HACKER:
+				modified.technique *= 2;
+				modified.attack *= 1.3;
+				modified.defend *= .7;
+				break;
+			case PlayerArchetype.JEONGBO_YOWON:
+				modified.technique *= 1.8;
+				modified.attack *= 1.6;
+				modified.defend *= .6;
+				modified.retreat *= .5;
+				break;
+			case PlayerArchetype.JOJIK_POKRYEOKBAE:
+				modified.attack *= 2.2;
+				modified.technique *= 1.7;
+				modified.defend *= .4;
+				modified.retreat *= 1.2;
+				break;
+		}
+		return modified;
+	}
+	/**
+	* Apply Intelligence Operative (Jeongbo Yowon) vulnerability exploitation
+	*
+	* Enhances decision weights to exploit opponent's defenseless states with precision:
+	* - **HELPLESS (balance === HELPLESS)**: 90% takedown priority - Execute precision takedown
+	* - **VULNERABLE (balance === VULNERABLE)**: 70% aggressive attack - Sustained pressure tactics
+	* - **SHAKEN (balance === SHAKEN)**: 50% pressure increase - Psychological warfare
+	* - **Low Stamina (< 20%)**: 60% exploitation - Force defensive positions
+	* - **No Ki (< 10%)**: 50% technique spam - Prevent powerful techniques
+	*
+	* **Multiplier Stacking Behavior**:
+	* When multiple vulnerabilities are present, multipliers stack multiplicatively:
+	* - VULNERABLE (2.0x attack) + low stamina (1.5x attack) = 3.0x total attack multiplier
+	* - VULNERABLE (1.8x technique) + low ki (1.4x technique) = 2.52x total technique multiplier
+	* This creates increasingly aggressive exploitation as opponent becomes more vulnerable.
+	* Note: HELPLESS state uses exclusive else-if, so it doesn't stack with VULNERABLE/SHAKEN.
+	*
+	* **Jeongbo Philosophy (정보요원 전략)**:
+	* - Knowledge through observation (관찰을 통한 지식)
+	* - Psychological manipulation (심리적 조작)
+	* - Precise timing (정확한 타이밍)
+	* - Strategic exploitation (전략적 공략)
+	*
+	* This function provides 3x higher vulnerability exploitation rate than Musa,
+	* 2x higher psychological warfare usage than Amsalja, and 5x higher takedown
+	* success rate when opponent is HELPLESS.
+	*
+	* @korean 정보요원 취약성 공략
+	*
+	* @param weights - Base action weight multipliers
+	* @param vulnerability - Vulnerability assessment context
+	* @param personality - AI personality archetype
+	* @returns Modified action weights for Jeongbo exploitation
+	*/
+	applyJeongboExploitation(weights, vulnerability, personality) {
+		if (personality.archetype !== PlayerArchetype.JEONGBO_YOWON) return weights;
+		const modified = { ...weights };
+		if (this.shouldExecutePressureStrike(vulnerability)) {
+			modified.technique *= 3;
+			modified.attack *= .3;
+			return modified;
+		}
+		if (vulnerability.isHelpless) {
+			modified.technique *= 5;
+			modified.attack *= .2;
+			modified.defend *= .1;
+			modified.feint *= .1;
+		} else if (vulnerability.isVulnerable) {
+			modified.attack *= 2;
+			modified.technique *= 1.8;
+			modified.feint *= .5;
+			modified.defend *= .5;
+		} else if (vulnerability.isShaken) {
+			modified.feint *= 2;
+			modified.circle *= 1.5;
+			modified.technique *= 1.3;
+		}
+		if (vulnerability.hasLowStamina) {
+			modified.attack *= 1.5;
+			modified.approach *= 1.3;
+		}
+		if (vulnerability.hasNoKi) {
+			modified.technique *= 1.4;
+			modified.attack *= 1.3;
+		}
+		return modified;
+	}
+	/**
+	* Build psychological pressure through intimidation tactics
+	*
+	* Intelligence Operative uses feints, circling, and approach/retreat patterns
+	* to build cumulative psychological pressure on opponent. When pressure reaches
+	* 50+ and opponent is VULNERABLE, triggers decisive strike.
+	*
+	* **Psychological Tactics (심리전 전술)**:
+	* - Feints: +10 pressure (fake attacks create hesitation)
+	* - Circling: +5 pressure (predator circling prey)
+	* - Approach: +3 pressure (aggressive positioning)
+	* - Decay: -3 pressure per second (pressure fades without action)
+	*
+	* @korean 심리적 압박 증가
+	*
+	* @param actionType - Type of action taken (FEINT, CIRCLE, APPROACH, etc.)
+	* @param now - Current timestamp for decay calculation
+	*/
+	buildPsychologicalPressure(actionType, now) {
+		if (this.lastPressureActionTime > 0) {
+			const decayAmount = (now - this.lastPressureActionTime) / 1e3 * 3;
+			this.psychologicalPressure = Math.max(0, this.psychologicalPressure - decayAmount);
+		}
+		switch (actionType) {
+			case AIActionType.FEINT:
+				this.psychologicalPressure = Math.min(100, this.psychologicalPressure + 10);
+				this.lastPressureActionTime = now;
+				break;
+			case AIActionType.CIRCLE:
+				this.psychologicalPressure = Math.min(100, this.psychologicalPressure + 5);
+				this.lastPressureActionTime = now;
+				break;
+			case AIActionType.APPROACH:
+				this.psychologicalPressure = Math.min(100, this.psychologicalPressure + 3);
+				this.lastPressureActionTime = now;
+				break;
+			case AIActionType.ATTACK:
+			case AIActionType.TECHNIQUE:
+				this.psychologicalPressure = Math.max(0, this.psychologicalPressure * .5);
+				break;
+		}
+	}
+	/**
+	* Check if psychological pressure should trigger decisive strike
+	*
+	* Jeongbo executes decisive technique when:
+	* - Psychological pressure ≥ 50 (sustained intimidation)
+	* - Opponent is VULNERABLE or worse (balance < 30)
+	* - Returns true to boost technique priority
+	*
+	* @korean 심리적 압박 결정타 확인
+	*
+	* @param vulnerability - Vulnerability assessment context
+	* @returns True if pressure warrants decisive strike
+	*/
+	shouldExecutePressureStrike(vulnerability) {
+		return this.psychologicalPressure >= 50 && (vulnerability.isVulnerable || vulnerability.isHelpless);
+	}
+	/**
+	* Analyze counter-attack opportunity from opponent's limb exposure.
+	*
+	* **Korean**: 반격 기회 분석 (Counter Opportunity Analysis)
+	*
+	* Detects when the opponent has exposed limbs during technique execution,
+	* enabling defensive counter-attacks and breaking techniques.
+	*
+	* This integrates the LimbExposureSystem with AI decision-making by:
+	* 1. Detecting exposed limbs from opponent's current technique
+	* 2. Calculating vulnerability windows and multipliers
+	* 3. Providing counter opportunity data for decision prioritization
+	*
+	* @param context - Combat context with opponent technique data
+	* @returns Enhanced context with counter opportunity analysis, or undefined if no opportunity
+	*
+	* @remarks
+	* Returns undefined if:
+	* - Opponent is not executing a technique
+	* - Technique has no exposure window defined
+	* - Current time is outside the exposure window
+	*
+	* @korean 반격기회분석
+	*/
+	analyzeCounterOpportunity(context) {
+		const counterOpportunity = context.counterOpportunity;
+		return {
+			counterOpportunity,
+			opponentVulnerability: counterOpportunity?.vulnerabilityMultiplier ?? 1
+		};
+	}
+	/**
+	* Make strategic decision based on combat context
+	*
+	* Applies difficulty-based reaction time delays if difficulty parameters are set
+	*/
+	makeDecision(context, personality, comboSystem) {
+		const now = Date.now();
+		const reactionDelay = this.difficultyParams ? this.currentReactionDelay : this.decisionCooldown;
+		const effectiveCooldown = Math.max(this.decisionCooldown, reactionDelay);
+		if (now - this.lastDecisionTime < effectiveCooldown) return {
+			action: AIActionType.WAIT,
+			priority: 0,
+			reason: this.difficultyParams ? `Reaction time delay: ${effectiveCooldown.toFixed(0)}ms` : "Decision cooldown active"
+		};
+		this.lastDecisionTime = now;
+		const isBelowRetreatThreshold = context.playerHealth / context.playerMaxHealth < personality.tacticalRetreatThreshold;
+		const opponentMaxHealth = context.opponentMaxHealth ?? context.playerMaxHealth;
+		const isKillOpportunity = context.opponentHealth / opponentMaxHealth < .3;
+		const isOpponentVulnerable = context.opponentBalance === "VULNERABLE" || context.opponentBalance === "HELPLESS";
+		if (personality.archetype === PlayerArchetype.HACKER && context.timeInMatch < HACKER_OBSERVATION_DURATION_MS && !isBelowRetreatThreshold && !isKillOpportunity && !isOpponentVulnerable) return {
+			action: HACKER_OBSERVATION_ACTIONS[Math.floor(Math.random() * HACKER_OBSERVATION_ACTIONS.length)],
+			priority: 10,
+			reason: `Hacker observation phase: collecting data (${(context.timeInMatch / 1e3).toFixed(1)}s / ${HACKER_OBSERVATION_DURATION_MS / 1e3}s) (해커 관찰 단계)`
+		};
+		const killModeActive = this.isKillModeActive(context, personality);
+		const vulnerability = assessVulnerability(context);
+		const counterAnalysis = this.analyzeCounterOpportunity(context);
+		if (comboSystem.isComboActive()) return this.decideComboAction(context, personality);
+		const decisions = [];
+		const optimalRange = this.getOptimalRange(personality, context);
+		const distance = context.distanceToOpponent;
+		decisions.push(this.evaluateSurvival(context, personality));
+		if (counterAnalysis.counterOpportunity) decisions.push(this.evaluateLimbExposureCounter(context, personality, counterAnalysis.counterOpportunity, counterAnalysis.opponentVulnerability));
+		if (context.isOpponentAttacking) decisions.push(this.evaluateCounter(context, personality, killModeActive));
+		if (distance < optimalRange * 1.5) decisions.push(this.evaluateComboStart(context, personality, comboSystem));
+		decisions.push(this.evaluateStanceChange(context, personality, now));
+		if (distance < optimalRange * 1.8 && !killModeActive) decisions.push(this.evaluateFeint(context, personality));
+		if (distance <= optimalRange * 2) decisions.push(this.evaluateCloseRange(context, personality, killModeActive));
+		else if (distance > optimalRange * 2.5) decisions.push(this.evaluateApproach(context, personality, killModeActive));
+		else decisions.push(this.evaluateMidRange(context, personality));
+		if (!killModeActive || personality.archetype !== PlayerArchetype.MUSA) decisions.push(this.evaluateDefense(context, personality));
+		let modifiedDecisions = decisions;
+		if (personality.archetype === PlayerArchetype.JEONGBO_YOWON) modifiedDecisions = decisions.map((decision) => {
+			const SURVIVAL_REASON_KEYWORDS = [
+				"critical health",
+				"high pain",
+				"survival retreat",
+				"emergency retreat",
+				"위급 상황",
+				"고통 회피"
+			];
+			const reasonLower = decision.reason.toLowerCase();
+			const hasSurvivalKeyword = SURVIVAL_REASON_KEYWORDS.some((keyword) => reasonLower.includes(keyword));
+			if (decision.action === AIActionType.RETREAT && (decision.priority === 20 || hasSurvivalKeyword)) return decision;
+			if (![
+				AIActionType.ATTACK,
+				AIActionType.TECHNIQUE,
+				AIActionType.DEFEND,
+				AIActionType.FEINT,
+				AIActionType.APPROACH,
+				AIActionType.CIRCLE
+			].includes(decision.action)) return decision;
+			const weights = {
+				attack: decision.action === AIActionType.ATTACK ? 1 : 0,
+				technique: decision.action === AIActionType.TECHNIQUE ? 1 : 0,
+				defend: decision.action === AIActionType.DEFEND ? 1 : 0,
+				feint: decision.action === AIActionType.FEINT ? 1 : 0,
+				approach: decision.action === AIActionType.APPROACH ? 1 : 0,
+				circle: decision.action === AIActionType.CIRCLE ? 1 : 0
+			};
+			const modifiedWeights = this.applyJeongboExploitation(weights, vulnerability, personality);
+			let newPriority = decision.priority;
+			if (decision.action === AIActionType.ATTACK) newPriority = decision.priority * modifiedWeights.attack;
+			else if (decision.action === AIActionType.TECHNIQUE) newPriority = decision.priority * modifiedWeights.technique;
+			else if (decision.action === AIActionType.DEFEND) newPriority = decision.priority * modifiedWeights.defend;
+			else if (decision.action === AIActionType.FEINT) newPriority = decision.priority * modifiedWeights.feint;
+			else if (decision.action === AIActionType.APPROACH) newPriority = decision.priority * modifiedWeights.approach;
+			else if (decision.action === AIActionType.CIRCLE) newPriority = decision.priority * modifiedWeights.circle;
+			return {
+				...decision,
+				priority: newPriority
+			};
+		});
+		if (killModeActive) {
+			modifiedDecisions = modifiedDecisions.map((decision) => {
+				const SURVIVAL_REASON_KEYWORDS = [
+					"critical health",
+					"high pain",
+					"survival retreat",
+					"emergency retreat",
+					"위급 상황",
+					"고통 회피"
+				];
+				const reasonLower = decision.reason.toLowerCase();
+				const hasSurvivalKeyword = SURVIVAL_REASON_KEYWORDS.some((keyword) => reasonLower.includes(keyword));
+				if (decision.action === AIActionType.RETREAT && (decision.priority === 20 || hasSurvivalKeyword)) return decision;
+				const weights = {
+					attack: decision.action === AIActionType.ATTACK ? 1 : 0,
+					technique: decision.action === AIActionType.TECHNIQUE ? 1 : 0,
+					defend: decision.action === AIActionType.DEFEND ? 1 : 0,
+					retreat: decision.action === AIActionType.RETREAT ? 1 : 0
+				};
+				const modifiedWeights = this.applyKillModeModifiers(weights, personality, true);
+				let newPriority = decision.priority;
+				if (decision.action === AIActionType.ATTACK) newPriority = decision.priority * modifiedWeights.attack;
+				else if (decision.action === AIActionType.TECHNIQUE) newPriority = decision.priority * modifiedWeights.technique;
+				else if (decision.action === AIActionType.DEFEND) newPriority = decision.priority * modifiedWeights.defend;
+				else if (decision.action === AIActionType.RETREAT) newPriority = decision.priority * modifiedWeights.retreat;
+				return {
+					...decision,
+					priority: newPriority
+				};
+			});
+			const bestDecision = modifiedDecisions.reduce((best, current) => current.priority > best.priority ? current : best);
+			if (personality.archetype === PlayerArchetype.JEONGBO_YOWON) this.buildPsychologicalPressure(bestDecision.action, now);
+			if (bestDecision.action === AIActionType.ATTACK || bestDecision.action === AIActionType.TECHNIQUE) this.consecutiveAttacks++;
+			else this.consecutiveAttacks = 0;
+			return enforceArchetypeBehavior(bestDecision, personality.archetype, context);
+		}
+		const bestDecision = modifiedDecisions.reduce((best, current) => current.priority > best.priority ? current : best);
+		if (personality.archetype === PlayerArchetype.JEONGBO_YOWON) this.buildPsychologicalPressure(bestDecision.action, now);
+		if (bestDecision.action === AIActionType.ATTACK || bestDecision.action === AIActionType.TECHNIQUE) this.consecutiveAttacks++;
+		else this.consecutiveAttacks = 0;
+		return enforceArchetypeBehavior(bestDecision, personality.archetype, context);
+	}
+	/**
+	* Evaluate survival tactics when critically low health
+	*
+	* **Korean Philosophy (생존 전략)**:
+	* - Consider both health and pain levels
+	* - Archetype affects retreat threshold and behavior
+	* - Honor code (Musa) prevents retreat above threshold
+	*/
+	evaluateSurvival(context, personality) {
+		const healthPercent = context.playerHealth / context.playerMaxHealth;
+		const painLevel = context.recentDamageTaken;
+		const behavior = getArchetypeBehavior(personality.archetype);
+		const isCritical = healthPercent < personality.tacticalRetreatThreshold;
+		if (isCritical || healthPercent < .5 && painLevel > 50) {
+			if (behavior.honorCode && healthPercent > behavior.retreatThreshold / 100) return {
+				action: AIActionType.WAIT,
+				priority: 0,
+				reason: `Honor code prevents retreat: ${(healthPercent * 100).toFixed(1)}% (명예 규범)`
+			};
+			const retreatVector = this.calculateRetreatPosition(context);
+			return {
+				action: AIActionType.RETREAT,
+				targetPosition: retreatVector,
+				priority: 20,
+				reason: isCritical ? `Critical health: ${(healthPercent * 100).toFixed(1)}% (위급 상황)` : `High pain: ${painLevel.toFixed(0)} (고통 회피)`
+			};
+		}
+		return {
+			action: AIActionType.WAIT,
+			priority: 0,
+			reason: "Health stable"
+		};
+	}
+	/**
+	* Evaluate counter-attack opportunity
+	*
+	* **Kill Mode Enhancement (결정타 반격)**:
+	* All archetypes enhance counter behavior during kill mode based on philosophy:
+	* - **Musa**: Increased counter frequency (honor demands swift response)
+	* - **Amsalja**: Enhanced counter timing with precision strikes
+	* - **Hacker**: Calculated counter-attacks (analytical opportunity)
+	* - **Jeongbo Yowon**: Strategic counters (psychological advantage)
+	* - **Jojik Pokryeokbae**: Opportunistic counters (dirty tactics)
+	*
+	* @param context - Combat context
+	* @param personality - AI personality
+	* @param killModeActive - Whether kill mode is active
+	*/
+	evaluateCounter(context, personality, killModeActive = false) {
+		let counterChance = personality.defensePreference * .8;
+		let counterPriority = 8;
+		if (killModeActive) switch (personality.archetype) {
+			case PlayerArchetype.MUSA:
+				counterChance = Math.min(.95, counterChance + .3);
+				counterPriority = 9;
+				break;
+			case PlayerArchetype.AMSALJA:
+				counterChance = Math.min(.9, counterChance + .25);
+				counterPriority = 9;
+				break;
+			case PlayerArchetype.HACKER:
+				counterChance = Math.min(.85, counterChance + .15);
+				counterPriority = 9;
+				break;
+			case PlayerArchetype.JEONGBO_YOWON:
+				counterChance = Math.min(.8, counterChance + .2);
+				counterPriority = 8;
+				break;
+			case PlayerArchetype.JOJIK_POKRYEOKBAE:
+				counterChance = Math.min(.85, counterChance + .25);
+				counterPriority = 8;
+				break;
+		}
+		const maxReach = this.getArchetypeMaxReach(personality.archetype);
+		if (Math.random() < counterChance && context.distanceToOpponent < maxReach) {
+			let killModeReason = "";
+			if (killModeActive) switch (personality.archetype) {
+				case PlayerArchetype.MUSA:
+					killModeReason = " - 명예 반격 (honor counter)";
+					break;
+				case PlayerArchetype.AMSALJA:
+					killModeReason = " - 정밀 반격 (precision counter)";
+					break;
+				case PlayerArchetype.HACKER:
+					killModeReason = " - 분석 반격 (analytical counter)";
+					break;
+				case PlayerArchetype.JEONGBO_YOWON:
+					killModeReason = " - 전략 반격 (strategic counter)";
+					break;
+				case PlayerArchetype.JOJIK_POKRYEOKBAE:
+					killModeReason = " - 기습 반격 (opportunistic counter)";
+					break;
+			}
+			return {
+				action: AIActionType.COUNTER,
+				priority: counterPriority,
+				reason: `Opponent attacking - counter opportunity${killModeReason}`
+			};
+		}
+		return {
+			action: AIActionType.DEFEND,
+			priority: 6,
+			reason: "Opponent attacking - defensive stance"
+		};
+	}
+	/**
+	* Evaluate counter-attack opportunity from limb exposure.
+	*
+	* **Korean**: 사지 노출 반격 평가 (Limb Exposure Counter Evaluation)
+	*
+	* Analyzes opportunities to exploit opponent's exposed limbs during technique
+	* execution. This is higher priority than standard counters because it targets
+	* specific anatomical vulnerabilities.
+	*
+	* **Defensive Archetype Priority**:
+	* Defensive archetypes (high defensiveness) strongly favor counter-attacks:
+	* - **Musa**: Honorable defense with precise counters (defensiveness ~0.7)
+	* - **Amsalja**: Patient assassin waiting for openings (defensiveness ~0.6)
+	* - **Jeongbo Yowon**: Analytical exploitation of weaknesses (defensiveness ~0.5)
+	*
+	* **Breaking Techniques**:
+	* When allowsBreaking is true, AI can execute joint locks and limb breaks
+	* for severe damage and mobility reduction.
+	*
+	* @param context - Combat context with positioning
+	* @param personality - AI personality with archetype and defensiveness
+	* @param counterOpportunity - Detected limb exposure opportunity
+	* @param opponentVulnerability - Opponent's vulnerability multiplier
+	* @returns Counter-attack decision with priority based on archetype
+	*
+	* @korean 사지노출반격평가
+	*/
+	evaluateLimbExposureCounter(context, personality, counterOpportunity, opponentVulnerability) {
+		let counterPriority = 9;
+		const defensivenessBonus = personality.defensePreference * 3;
+		counterPriority += defensivenessBonus;
+		if (counterOpportunity.allowsBreaking) counterPriority += 2;
+		if (opponentVulnerability > 2) counterPriority += 1;
+		else if (opponentVulnerability > 1.5) counterPriority += .5;
+		if (!(context.playerStamina > context.playerMaxStamina * .2)) counterPriority -= 3;
+		const maxCounterRange = 1;
+		if (context.distanceToOpponent > maxCounterRange) return {
+			action: AIActionType.WAIT,
+			priority: 0,
+			reason: `Limb exposed but too far: ${context.distanceToOpponent.toFixed(2)}m > ${maxCounterRange}m`
+		};
+		const exposedLimbKorean = this.translateExposedLimb(counterOpportunity.exposedLimb);
+		const breakingNote = counterOpportunity.allowsBreaking ? " - 파쇄 가능 (breaking possible)" : "";
+		const vulnerabilityNote = ` (취약성: ${opponentVulnerability.toFixed(1)}x)`;
+		return {
+			action: AIActionType.COUNTER,
+			priority: counterPriority,
+			reason: `Exposed limb counter: ${counterOpportunity.exposedLimb} (${exposedLimbKorean})${breakingNote}${vulnerabilityNote}`
+		};
+	}
+	/**
+	* Translate exposed limb type to Korean.
+	*
+	* **Korean**: 노출 사지 번역 (Exposed Limb Translation)
+	*
+	* @param exposedLimb - English limb type identifier
+	* @returns Korean translation
+	*
+	* @korean 노출사지번역
+	*/
+	translateExposedLimb(exposedLimb) {
+		return {
+			left_arm: "왼팔",
+			right_arm: "오른팔",
+			left_elbow: "왼팔꿈치",
+			right_elbow: "오른팔꿈치",
+			left_wrist: "왼손목",
+			right_wrist: "오른손목",
+			left_leg: "왼다리",
+			right_leg: "오른다리",
+			left_knee: "왼무릎",
+			right_knee: "오른무릎",
+			left_ankle: "왼발목",
+			right_ankle: "오른발목"
+		}[exposedLimb];
+	}
+	/**
+	* Evaluate combo initiation (fix for issue #2529467014)
+	*/
+	evaluateComboStart(context, personality, comboSystem) {
+		if (comboSystem.isComboActive()) return {
+			action: AIActionType.WAIT,
+			priority: 0,
+			reason: "Combo already active"
+		};
+		if (this.consecutiveAttacks > 0) return {
+			action: AIActionType.WAIT,
+			priority: 0,
+			reason: "Combo cooldown"
+		};
+		const hasResources = context.playerKi > context.playerMaxKi * .3 && context.playerStamina > context.playerMaxStamina * .3;
+		const mediumRange = this.getArchetypeMediumRange(personality.archetype);
+		const goodDistance = context.distanceToOpponent < mediumRange;
+		const comboChance = Math.random() < personality.comboTendency;
+		if (hasResources && goodDistance && comboChance) return {
+			action: AIActionType.COMBO,
+			priority: 7,
+			reason: "Initiating combo sequence"
+		};
+		return {
+			action: AIActionType.WAIT,
+			priority: 0,
+			reason: "Combo conditions not met"
+		};
+	}
+	/**
+	* Select stance based on distance to opponent
+	*
+	* Chooses optimal stance for current combat range, prioritizing:
+	* 1. Overlap between distance-optimal stances and archetype preferred stances
+	* 2. Any distance-optimal stance if no overlap exists (expands tactical repertoire)
+	* 3. Avoids switching to current stance
+	*
+	* **Distance Categories**:
+	* - CLOSE (≤2 cells / 80px): GEON, JIN, LI, SON - Aggressive close-quarters stances
+	* - MID (3-4 cells / 120-160px): GAM, TAE, GAN - Adaptive mid-range stances
+	* - FAR (≥5 cells / 200px+): GAN, GON - Defensive distance stances
+	*
+	* @korean 거리별 자세 선택
+	*
+	* **Physics-First**: Distance parameter is in METERS.
+	*
+	* @param distance - Distance to opponent in meters
+	* @param preferredStances - Archetype's preferred stances
+	* @param currentStance - Current stance (to avoid redundant switches)
+	* @returns Optimal stance for distance, or undefined if no valid options
+	*/
+	selectStanceForDistance(distance, preferredStances, currentStance, archetype) {
+		const closeRange = this.getArchetypeCloseRange(archetype);
+		const mediumRange = this.getArchetypeMediumRange(archetype);
+		let distanceCategory;
+		if (distance <= closeRange) distanceCategory = "CLOSE";
+		else if (distance <= mediumRange) distanceCategory = "MID";
+		else distanceCategory = "FAR";
+		const optimalStances = DISTANCE_BASED_STANCES[distanceCategory];
+		const candidates = optimalStances.filter((s) => preferredStances.includes(s));
+		const filtered = (candidates.length > 0 ? candidates : optimalStances).filter((s) => s !== currentStance);
+		if (filtered.length === 0) return;
+		return filtered[Math.floor(Math.random() * filtered.length)];
+	}
+	/**
+	* Evaluate stance change using TrigramSystem and distance-based selection
+	*
+	* **Korean Philosophy (자세 전환)**:
+	* Uses I Ching-based trigram system to find optimal stance transitions.
+	* Considers resource costs, counter-stance effectiveness, archetype preferences,
+	* and distance-based tactical positioning.
+	*
+	* **Dynamic Stance Rotation (Issue #dynamic-ai-stance-rotation)**:
+	* - Integrates distance-based stance selection for tactical variety
+	* - Prioritizes counter-stances for opponent matchup advantage
+	* - Expands tactical repertoire beyond archetype preferences when needed
+	*/
+	evaluateStanceChange(context, personality, now) {
+		if (now - this.lastStanceChange < this.stanceChangeCooldown) return {
+			action: AIActionType.WAIT,
+			priority: 0,
+			reason: "Stance change on cooldown"
+		};
+		const behavior = getArchetypeBehavior(personality.archetype);
+		const timeInStance = Math.max(0, context.stanceFatigue?.timeInStance ?? 0);
+		const fatigueModifier = this.getStanceFatigueModifier(timeInStance);
+		const adjustedSwitchFrequency = Math.min(.95, personality.stanceSwitchFrequency * fatigueModifier);
+		if (!(Math.random() < adjustedSwitchFrequency)) return {
+			action: AIActionType.WAIT,
+			priority: 0,
+			reason: fatigueModifier > 1 ? `Stance change deferred (fatigue: ${fatigueModifier.toFixed(2)}x, probability: ${(adjustedSwitchFrequency * 100).toFixed(1)}%)` : "No stance change needed"
+		};
+		if (behavior.preferredStances.includes(context.playerStance) && !context.isOpponentAttacking && Math.random() < .6) {
+			const fatigueOverrideProbability = fatigueModifier > 1 ? Math.min(.8, (fatigueModifier - 1) * AIDecisionTree.FATIGUE_OVERRIDE_SCALING_FACTOR) : 0;
+			if (!(fatigueModifier > 1.2 && Math.random() < fatigueOverrideProbability)) return {
+				action: AIActionType.WAIT,
+				priority: 0,
+				reason: "Already in preferred stance (선호 자세 유지)"
+			};
+		}
+		const playerState = {
+			currentStance: context.playerStance,
+			ki: context.playerKi,
+			stamina: context.playerStamina,
+			archetype: personality.archetype
+		};
+		const distanceStance = this.selectStanceForDistance(context.distanceToOpponent, behavior.preferredStances, context.playerStance, personality.archetype);
+		if (distanceStance && this.trigramSystem.canTransitionTo(context.playerStance, distanceStance, playerState)) {
+			this.lastStanceChange = now;
+			return {
+				action: AIActionType.STANCE_CHANGE,
+				targetStance: distanceStance,
+				priority: 5,
+				reason: `Distance-optimal stance (거리 최적 자세: ${distanceStance})`
+			};
+		}
+		const counterStance = this.trigramSystem.getCounterStance(context.opponentStance);
+		if (counterStance !== context.playerStance && this.trigramSystem.canTransitionTo(context.playerStance, counterStance, playerState)) {
+			this.lastStanceChange = now;
+			return {
+				action: AIActionType.STANCE_CHANGE,
+				targetStance: counterStance,
+				priority: 5,
+				reason: `Counter stance to ${context.opponentStance} (상극 대응)`
+			};
+		}
+		const recommendedStance = this.trigramSystem.recommendStance(playerState);
+		if (this.trigramSystem.canTransitionTo(context.playerStance, recommendedStance, playerState)) {
+			this.lastStanceChange = now;
+			return {
+				action: AIActionType.STANCE_CHANGE,
+				targetStance: recommendedStance,
+				priority: 4,
+				reason: `Optimal stance transition via TrigramSystem (팔괘 전환)`
+			};
+		}
+		const preferredAvailable = behavior.preferredStances.find((stance) => stance !== context.playerStance && this.trigramSystem.canTransitionTo(context.playerStance, stance, playerState));
+		if (preferredAvailable) {
+			this.lastStanceChange = now;
+			return {
+				action: AIActionType.STANCE_CHANGE,
+				targetStance: preferredAvailable,
+				priority: 4,
+				reason: `Switching to preferred stance (선호 자세 전환: ${preferredAvailable})`
+			};
+		}
+		return {
+			action: AIActionType.WAIT,
+			priority: 0,
+			reason: "No viable stance transition"
+		};
+	}
+	/**
+	* Evaluate feint attack
+	*/
+	evaluateFeint(context, personality) {
+		const maxReach = this.getArchetypeMaxReach(personality.archetype);
+		if (Math.random() < personality.feintChance && context.distanceToOpponent < maxReach) return {
+			action: AIActionType.FEINT,
+			priority: 4,
+			reason: "Feinting to bait opponent"
+		};
+		return {
+			action: AIActionType.WAIT,
+			priority: 0,
+			reason: "No feint opportunity"
+		};
+	}
+	/**
+	* Evaluate close range tactics with vital point targeting
+	*
+	* **Korean Philosophy (급소 공격)**:
+	* At close range, AI targets specific vital points based on difficulty level.
+	* Higher difficulty = more precise targeting of critical points.
+	*
+	* **Kill Mode Enhancement (결정타)**:
+	* When kill mode is active, AI prioritizes finishing techniques with boosted priority.
+	*
+	* @param context - Combat context
+	* @param personality - AI personality
+	* @param killModeActive - Whether kill mode is active (opponent <30% health or vulnerable)
+	*/
+	evaluateCloseRange(context, personality, killModeActive = false) {
+		const hasResources = context.playerKi > 10 && context.playerStamina > 15;
+		const aggression = personality.aggressionLevel;
+		const targetVitalPoint = this.selectVitalPointTarget(context, personality);
+		const vitalPointName = targetVitalPoint ? getVitalPointById(targetVitalPoint)?.names.korean ?? targetVitalPoint : void 0;
+		if (killModeActive) {
+			const killModeSuffix = personality.archetype === PlayerArchetype.MUSA ? " (결정타 - 압도적 공격)" : " (결정타 - 즉사 기술)";
+			if (hasResources) return {
+				action: AIActionType.TECHNIQUE,
+				targetVitalPoint,
+				priority: targetVitalPoint ? 10 : 9,
+				reason: targetVitalPoint ? `Kill mode - finishing technique on vital point (급소 결정타: ${vitalPointName})${killModeSuffix}` : `Kill mode - finishing technique${killModeSuffix}`
+			};
+			else return {
+				action: AIActionType.ATTACK,
+				targetVitalPoint,
+				priority: targetVitalPoint ? 9 : 8,
+				reason: targetVitalPoint ? `Kill mode - finishing attack (결정타 급소: ${vitalPointName})${killModeSuffix}` : `Kill mode - finishing attack${killModeSuffix}`
+			};
+		}
+		const actionRoll = Math.random();
+		const attackThreshold = aggression * .95;
+		const techniqueThreshold = hasResources ? aggression * .5 : 0;
+		if (actionRoll < attackThreshold) return {
+			action: AIActionType.ATTACK,
+			targetVitalPoint,
+			priority: targetVitalPoint ? 8 : 7,
+			reason: targetVitalPoint ? `Close range - vital point attack (급소 타격: ${vitalPointName})` : "Close range - aggressive strike"
+		};
+		else if (actionRoll < attackThreshold + techniqueThreshold && hasResources) return {
+			action: AIActionType.TECHNIQUE,
+			targetVitalPoint,
+			priority: targetVitalPoint ? 8 : 7,
+			reason: targetVitalPoint ? `Close range - technique on vital point (급소 기술: ${vitalPointName})` : "Close range - technique execution"
+		};
+		else return {
+			action: AIActionType.DEFEND,
+			priority: 4,
+			reason: "Close range - defensive posture (방어 자세)"
+		};
+	}
+	/**
+	* Select vital point to target based on difficulty and stance
+	*
+	* **Korean Philosophy (급소 선택)**:
+	* - Beginner AI: Random targeting or no specific target
+	* - Intermediate AI: Favors easier vital points
+	* - Advanced AI: Targets appropriate points for current stance
+	* - Master AI: Targets critical points with high precision
+	*/
+	selectVitalPointTarget(context, personality) {
+		if (KOREAN_VITAL_POINTS.length === 0) return;
+		const targetChance = this.difficultyLevel * personality.aggressionLevel;
+		if (Math.random() > targetChance) return;
+		const effectivePoints = KOREAN_VITAL_POINTS.filter((point) => point.effectiveStances?.includes(context.playerStance));
+		if (effectivePoints.length === 0) return KOREAN_VITAL_POINTS[Math.floor(Math.random() * KOREAN_VITAL_POINTS.length)].id;
+		if (this.difficultyLevel < .3) return effectivePoints[Math.floor(Math.random() * effectivePoints.length)].id;
+		else if (this.difficultyLevel < .6) {
+			const easierPoints = effectivePoints.filter((p) => p.targetingDifficulty < .7);
+			if (easierPoints.length > 0) return [...easierPoints].sort((a, b) => a.targetingDifficulty - b.targetingDifficulty)[0].id;
+			return effectivePoints[0].id;
+		} else {
+			const criticalPoints = effectivePoints.filter((p) => p.severity === "critical" || p.severity === "major");
+			if (criticalPoints.length > 0) return [...criticalPoints].sort((a, b) => (b.baseDamage ?? 0) - (a.baseDamage ?? 0))[0].id;
+			return [...effectivePoints].sort((a, b) => (b.baseDamage ?? 0) - (a.baseDamage ?? 0))[0]?.id ?? effectivePoints[0].id;
+		}
+	}
+	/**
+	* Calculate stance fatigue modifier for increased switching probability
+	*
+	* Applies time-based modifiers to encourage dynamic stance rotation:
+	* - 0-10 seconds: No modifier (1.0x)
+	* - 10-20 seconds: +20% increase (1.2x multiplier)
+	* - 20+ seconds: +50% increase (1.5x multiplier)
+	*
+	* This ensures AI doesn't stay locked in one stance for extended periods,
+	* promoting the use of all 8 trigram stances throughout combat.
+	*
+	* **Korean Philosophy (자세 피로도)**:
+	* Remaining in one stance too long reduces tactical flexibility and
+	* makes the fighter predictable. The Eight Trigram system requires
+	* constant adaptation and flow between stances.
+	*
+	* @korean 자세 피로도 배율 계산
+	*
+	* @param timeInStance - Time in current stance in milliseconds
+	* @returns Stance switch frequency multiplier (1.0 = no change, >1.0 = increased probability)
+	*/
+	getStanceFatigueModifier(timeInStance) {
+		if (timeInStance > 2e4) return 1.5;
+		if (timeInStance > 1e4) return 1.2;
+		return 1;
+	}
+	/**
+	* Get optimal combat range based on AI personality archetype
+	*
+	* Uses archetype behavior profiles to determine preferred combat distance.
+	* **Physics-First**: Returns distance in METERS directly.
+	*
+	* @param personality - AI personality with archetype behavior
+	* @param _context - Combat context (unused, kept for API compatibility)
+	* @returns Optimal range in meters
+	* @korean 최적 전투 거리 - 원형별 선호 거리 (미터)
+	*/
+	getOptimalRange(personality, _context) {
+		return getArchetypeBehavior(personality.archetype).optimalRange * .4;
+	}
+	/**
+	* Evaluate approach tactics with archetype-specific behavior
+	*
+	* **Korean Philosophy (접근 전략)**:
+	* - Musa charges directly (70% direct path)
+	* - Amsalja uses flanking movements (40% diagonal approach)
+	* - Hacker maintains optimal distance (prefers not to close too much)
+	*
+	* **Kill Mode Enhancement (결정타 접근)**:
+	* All archetypes enhance movement speed in kill mode based on combat philosophy:
+	* - **Musa**: Direct charging with leg shifts for maximum speed (40% faster)
+	* - **Amsalja**: Swift stepping patterns for rapid positioning (30% faster)
+	* - **Hacker**: Calculated approach for optimal strike position (20% faster)
+	* - **Jeongbo Yowon**: Strategic positioning for control (25% faster)
+	* - **Jojik Pokryeokbae**: Unpredictable rush for brutal finish (35% faster)
+	*
+	* @param context - Combat context
+	* @param personality - AI personality
+	* @param killModeActive - Whether kill mode is active
+	*/
+	evaluateApproach(context, personality, killModeActive = false) {
+		const optimalRange = this.getOptimalRange(personality, context);
+		const distance = context.distanceToOpponent;
+		if (distance <= optimalRange * 1.2) return {
+			action: AIActionType.WAIT,
+			priority: 0,
+			reason: "Already at optimal range"
+		};
+		let movementBias = this.getArchetypeMovementBias(personality.archetype);
+		if (killModeActive) switch (personality.archetype) {
+			case PlayerArchetype.MUSA:
+				movementBias *= 1.4;
+				break;
+			case PlayerArchetype.AMSALJA:
+				movementBias *= 1.3;
+				break;
+			case PlayerArchetype.HACKER:
+				movementBias *= 1.2;
+				break;
+			case PlayerArchetype.JEONGBO_YOWON:
+				movementBias *= 1.25;
+				break;
+			case PlayerArchetype.JOJIK_POKRYEOKBAE:
+				movementBias *= 1.35;
+				break;
+		}
+		let approachPos;
+		if (personality.archetype === PlayerArchetype.MUSA && Math.random() < .7) approachPos = this.calculateDirectApproach(context, killModeActive);
+		else if (personality.archetype === PlayerArchetype.AMSALJA && Math.random() < .4) approachPos = this.calculateFlankingApproach(context, killModeActive);
+		else approachPos = this.calculateApproachPosition(context);
+		let basePriority = 4;
+		if (killModeActive && distance > optimalRange * 1.5) switch (personality.archetype) {
+			case PlayerArchetype.MUSA:
+			case PlayerArchetype.JOJIK_POKRYEOKBAE:
+				basePriority = 6;
+				break;
+			case PlayerArchetype.AMSALJA:
+				basePriority = 6;
+				break;
+			case PlayerArchetype.HACKER:
+			case PlayerArchetype.JEONGBO_YOWON:
+				basePriority = 5;
+				break;
+		}
+		const priorityBoost = Math.min(2, (distance - optimalRange) / optimalRange) * movementBias * .8;
+		const finalPriority = basePriority + priorityBoost;
+		let killModeReason = "";
+		if (killModeActive) switch (personality.archetype) {
+			case PlayerArchetype.MUSA:
+				killModeReason = " - 돌격 (charging)";
+				break;
+			case PlayerArchetype.AMSALJA:
+				killModeReason = " - 신속 접근 (swift approach)";
+				break;
+			case PlayerArchetype.HACKER:
+				killModeReason = " - 분석 접근 (calculated approach)";
+				break;
+			case PlayerArchetype.JEONGBO_YOWON:
+				killModeReason = " - 전략 접근 (strategic approach)";
+				break;
+			case PlayerArchetype.JOJIK_POKRYEOKBAE:
+				killModeReason = " - 돌진 (rush)";
+				break;
+		}
+		return {
+			action: AIActionType.APPROACH,
+			targetPosition: approachPos,
+			priority: Math.min(9, finalPriority),
+			reason: `Moving closer (distance: ${Math.round(distance)}, optimal: ${optimalRange})${killModeReason}`
+		};
+	}
+	/**
+	* Get archetype-specific movement bias multipliers
+	*
+	* Applies movement pattern modifiers based on archetype behavior profiles:
+	* - Aggressive: High forward pressure (2.0x)
+	* - Evasive: Moderate mobility (1.5x)
+	* - Analytical: Conservative approach (0.8x-1.0x)
+	* - Unpredictable: Variable movement (1.3x)
+	*
+	* @korean 원형별 이동 성향
+	*/
+	getArchetypeMovementBias(archetype) {
+		switch (getArchetypeBehavior(archetype).movementPattern) {
+			case "aggressive": return 2;
+			case "evasive": return 1.5;
+			case "analytical": return archetype === PlayerArchetype.HACKER ? .8 : 1;
+			case "unpredictable": return 1.3;
+			default: return 1;
+		}
+	}
+	/**
+	* Calculate direct approach position (straight line to opponent)
+	* Used primarily by Musa archetype for charging attacks
+	*
+	* **Kill Mode Enhancement (결정타 돌격)**:
+	* - Larger step size for faster closing with leg shifts
+	* - Aggressive stride pattern for maximum forward momentum
+	*
+	* **Physics-First**: All calculations in METERS.
+	*
+	* @param context - Combat context
+	* @param killModeActive - Whether kill mode is active
+	*/
+	calculateDirectApproach(context, killModeActive = false) {
+		const dx = context.opponentPosition.x - context.playerPosition.x;
+		const dy = context.opponentPosition.y - context.playerPosition.y;
+		const distance = Math.sqrt(dx * dx + dy * dy);
+		if (distance < AI_MOVEMENT_METERS.MIN_DISTANCE_THRESHOLD) return this.clampToArenaBoundsMeters(context.playerPosition, context);
+		const baseStepSize = AI_MOVEMENT_METERS.STEP_SIZE;
+		const stepSize = killModeActive ? Math.min(baseStepSize * 1.5, distance) : Math.min(baseStepSize, distance);
+		return this.clampToArenaBoundsMeters({
+			x: context.playerPosition.x + dx / distance * stepSize,
+			y: context.playerPosition.y + dy / distance * stepSize
+		}, context);
+	}
+	/**
+	* Calculate flanking approach position (diagonal/side approach)
+	* Used primarily by Amsalja archetype for stealth positioning
+	*
+	* **Kill Mode Enhancement (결정타 측면 공격)**:
+	* - Tighter flanking angle for more aggressive positioning
+	* - Swift stepping pattern for rapid side movement
+	*
+	* **Physics-First**: All calculations in METERS.
+	*
+	* @param context - Combat context
+	* @param killModeActive - Whether kill mode is active
+	*/
+	calculateFlankingApproach(context, killModeActive = false) {
+		const dx = context.opponentPosition.x - context.playerPosition.x;
+		const dy = context.opponentPosition.y - context.playerPosition.y;
+		const distance = Math.sqrt(dx * dx + dy * dy);
+		if (distance < AI_MOVEMENT_METERS.MIN_DISTANCE_THRESHOLD) return this.clampToArenaBoundsMeters(context.playerPosition, context);
+		const baseFlankOffset = AI_MOVEMENT_METERS.FLANK_OFFSET_BASE + Math.random() * AI_MOVEMENT_METERS.FLANK_OFFSET_RANDOM;
+		const flankOffset = killModeActive ? baseFlankOffset * .7 : baseFlankOffset;
+		const perpX = -dy / distance;
+		const perpY = dx / distance;
+		const flankSide = Math.random() < .5 ? 1 : -1;
+		return this.clampToArenaBoundsMeters({
+			x: context.opponentPosition.x + perpX * flankOffset * flankSide,
+			y: context.opponentPosition.y + perpY * flankOffset * flankSide
+		}, context);
+	}
+	/**
+	* Clamp position to arena boundaries with proper margins
+	* Centralizes boundary validation logic for all movement calculations
+	*
+	* **Physics-First**: Works entirely in METERS using worldWidthMeters/worldDepthMeters.
+	* Arena is centered at origin (0,0), so bounds are -halfWidth to +halfWidth.
+	*
+	* @param position - Position to clamp (in meters)
+	* @param context - Combat context with arena dimensions in meters
+	*/
+	clampToArenaBoundsMeters(position, context) {
+		const halfWidth = context.arenaBounds.worldWidthMeters / 2;
+		const halfDepth = context.arenaBounds.worldDepthMeters / 2;
+		const marginX = AI_MOVEMENT_METERS.ARENA_MARGIN_X;
+		const marginY = AI_MOVEMENT_METERS.ARENA_MARGIN_Y;
+		return {
+			x: Math.max(-halfWidth + marginX, Math.min(halfWidth - marginX, position.x)),
+			y: Math.max(-halfDepth + marginY, Math.min(halfDepth - marginY, position.y))
+		};
+	}
+	/**
+	* Evaluate mid-range tactics with distance awareness
+	*
+	* **Korean Philosophy (중거리 전술)**:
+	* - Considers optimal range for archetype
+	* - Hacker prefers to maintain this range (analytical pattern)
+	* - Jeongbo uses strategic timing and analysis
+	* - Others may close or open distance based on situation
+	*/
+	evaluateMidRange(context, personality) {
+		const hasResources = context.playerKi > context.playerMaxKi * .3;
+		const optimalRange = this.getOptimalRange(personality, context);
+		const distance = context.distanceToOpponent;
+		const tacticRoll = Math.random();
+		const behavior = getArchetypeBehavior(personality.archetype);
+		if (behavior.movementPattern === "analytical" && Math.abs(distance - optimalRange) < .5) {
+			const circlePos = this.calculateCirclePosition(context);
+			const archetypeName = personality.archetype === PlayerArchetype.HACKER ? "사이버" : "정보";
+			return {
+				action: AIActionType.CIRCLE,
+				targetPosition: circlePos,
+				priority: 6,
+				reason: `${archetypeName} maintaining optimal mid-range (${archetypeName} 위치 유지)`
+			};
+		}
+		if (distance > optimalRange * 1.5) {
+			const approachPos = this.calculateApproachPosition(context);
+			return {
+				action: AIActionType.APPROACH,
+				targetPosition: approachPos,
+				priority: 5,
+				reason: "Moving to optimal range (최적 거리로 이동)"
+			};
+		}
+		if (distance < optimalRange * .7 && behavior.movementPattern === "analytical") {
+			const retreatPos = this.calculateRetreatPosition(context);
+			return {
+				action: AIActionType.RETREAT,
+				targetPosition: retreatPos,
+				priority: 5,
+				reason: "Creating tactical space (거리 확보)"
+			};
+		}
+		if (behavior.movementPattern === "unpredictable") {
+			const randomAction = tacticRoll < .33 ? "attack" : tacticRoll < .66 ? "circle" : "approach";
+			if (randomAction === "attack" && hasResources) return {
+				action: AIActionType.TECHNIQUE,
+				priority: 5,
+				reason: "Unpredictable attack (예측불가 공격)"
+			};
+			else if (randomAction === "circle") {
+				const circlePos = this.calculateCirclePosition(context);
+				return {
+					action: AIActionType.CIRCLE,
+					targetPosition: circlePos,
+					priority: 4,
+					reason: "Unpredictable movement (예측불가 이동)"
+				};
+			}
+		}
+		if (tacticRoll < .3 && hasResources) return {
+			action: AIActionType.TECHNIQUE,
+			priority: 5,
+			reason: "Mid-range technique (중거리 기술)"
+		};
+		else if (tacticRoll < .6) {
+			const circlePos = this.calculateCirclePosition(context);
+			return {
+				action: AIActionType.CIRCLE,
+				targetPosition: circlePos,
+				priority: 4,
+				reason: "Tactical repositioning (전술적 이동)"
+			};
+		} else {
+			const approachPos = this.calculateApproachPosition(context);
+			return {
+				action: AIActionType.APPROACH,
+				targetPosition: approachPos,
+				priority: 4,
+				reason: "Moving to optimal range (최적 거리로 이동)"
+			};
+		}
+	}
+	/**
+	* Evaluate defensive tactics
+	*/
+	evaluateDefense(context, personality) {
+		if (Math.random() < personality.defensePreference && context.recentDamageTaken > 20) return {
+			action: AIActionType.DEFEND,
+			priority: 6,
+			reason: "Defensive response to damage"
+		};
+		return {
+			action: AIActionType.WAIT,
+			priority: 0,
+			reason: "No defensive need"
+		};
+	}
+	/**
+	* Decide combo action
+	*/
+	decideComboAction(_context, _personality) {
+		return {
+			action: AIActionType.COMBO,
+			priority: 9,
+			reason: "Continuing active combo"
+		};
+	}
+	/**
+	* Calculate retreat position
+	*
+	* **Physics-First**: All calculations in METERS.
+	*/
+	calculateRetreatPosition(context) {
+		const dx = context.playerPosition.x - context.opponentPosition.x;
+		const dy = context.playerPosition.y - context.opponentPosition.y;
+		const distance = Math.sqrt(dx * dx + dy * dy);
+		const minDistance = AI_MOVEMENT_METERS.MIN_DISTANCE_THRESHOLD;
+		const retreatDistance = 1.5;
+		if (distance < minDistance) return this.clampToArenaBoundsMeters({
+			x: context.playerPosition.x + retreatDistance,
+			y: context.playerPosition.y
+		}, context);
+		const nx = dx / distance;
+		const ny = dy / distance;
+		return this.clampToArenaBoundsMeters({
+			x: context.playerPosition.x + nx * retreatDistance,
+			y: context.playerPosition.y + ny * retreatDistance
+		}, context);
+	}
+	/**
+	* Calculate approach position
+	*
+	* **Physics-First**: All calculations in METERS.
+	*/
+	calculateApproachPosition(context) {
+		const offsetX = (Math.random() - .5) * .8;
+		const offsetY = (Math.random() - .5) * .6;
+		return this.clampToArenaBoundsMeters({
+			x: context.opponentPosition.x + offsetX,
+			y: context.opponentPosition.y + offsetY
+		}, context);
+	}
+	/**
+	* Calculate circle position
+	*
+	* **Physics-First**: All calculations in METERS.
+	*/
+	calculateCirclePosition(context) {
+		const angle = Math.atan2(context.opponentPosition.y - context.playerPosition.y, context.opponentPosition.x - context.playerPosition.x);
+		const circleRadius = 1.5 + Math.random() * .5;
+		return this.clampToArenaBoundsMeters({
+			x: context.opponentPosition.x + Math.cos(angle + Math.PI / 2) * circleRadius,
+			y: context.opponentPosition.y + Math.sin(angle + Math.PI / 2) * circleRadius
+		}, context);
+	}
+	/**
+	* Reset decision state
+	*/
+	reset() {
+		this.lastDecisionTime = 0;
+		this.consecutiveAttacks = 0;
+		this.lastStanceChange = 0;
+		this.psychologicalPressure = 0;
+		this.lastPressureActionTime = 0;
+	}
+};
+//#endregion
+export { AIDecisionTree };
+
+//# sourceMappingURL=DecisionTree.js.map