blacktrigram 0.7.2

package/lib/components/screens/combat/hooks/useAICombat.js

@@ -0,0 +1,806 @@
+import { CombatAttackType, DamageType, PlayerArchetype } from "../../../../types/common.js";
+import { STANCE_REACH_MODIFIERS } from "../../../../types/physics.js";
+import "../../../../types/index.js";
+import { KoreanTechniquesSystem } from "../../../../systems/trigram/KoreanTechniques.js";
+import { physicalReachCalculator } from "../../../../systems/physics/PhysicalReachCalculator.js";
+import "../../../../systems/physics/index.js";
+import { getArchetypePhysicalAttributes } from "../../../../data/archetypePhysicalAttributes.js";
+import { getArchetypeBehavior } from "../../../../systems/ai/AIPersonality.js";
+import { AIComboSystem, getNextComboTechnique } from "../../../../systems/ai/ComboSystem.js";
+import { interpolateDifficultyParameters } from "../../../../systems/ai/AdaptiveDifficulty.js";
+import KOREAN_VITAL_POINTS from "../../../../systems/vitalpoint/KoreanVitalPoints.js";
+import { AIActionType } from "../../../../systems/ai/types.js";
+import { getSignatureMove, shouldExecuteSignatureMove } from "../../../../systems/ai/ArchetypeEnforcer.js";
+import { AIDecisionTree } from "../../../../systems/ai/DecisionTree.js";
+import "../../../../systems/ai/index.js";
+import { getBalanceState } from "../../../../utils/player3DHelpers.js";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+//#region src/components/screens/combat/hooks/useAICombat.ts
+/**
+* useAICombat Hook - AI Combat System Integration
+*
+* Custom hook for AI combat behavior with strategic decision-making.
+*
+* Manages AI opponent behavior including:
+* - Strategic decision-making via DecisionTree
+* - Combo attack sequences
+* - Adaptive difficulty based on player skill
+* - Performance monitoring (<10ms target for decisions)
+*
+* Side effects:
+* - Manages internal state for AI actions and aggression
+* - Sets up intervals/timers for AI action scheduling
+* - Updates state in response to combat events and round status
+*
+* @param config Configuration object for AI combat behavior.
+* @param config.player The AI-controlled player state.
+* @param config.opponent The opponent player state.
+* @param config.personality The AI's personality archetype.
+* @param config.adaptiveDifficulty Adaptive difficulty system instance.
+* @param config.arenaBounds Arena boundaries for movement validation.
+* @param config.roundStarted Whether the combat round has started.
+* @param config.roundEnded Whether the combat round has ended.
+* @param config.isPaused Whether the game is paused.
+* @param config.onExecuteAction Callback to execute AI actions.
+* @param config.onStanceChange Callback to handle stance changes.
+*
+* @returns AI combat state and control functions
+*
+* @example
+* ```typescript
+* const { aiState } = useAICombat({
+*   player: aiPlayer,
+*   opponent: humanPlayer,
+*   personality: AI_PERSONALITIES.AGGRESSIVE_STRIKER,
+*   adaptiveDifficulty,
+*   arenaBounds,
+*   roundStarted,
+*   roundEnded,
+*   isPaused,
+*   onExecuteAction: handleAction,
+*   onStanceChange: handleStanceChange,
+* });
+* ```
+*/
+var AI_DECISION_THRESHOLD_MS = 10;
+var WARNING_THROTTLE_MS = 5e3;
+/**
+* Technique range system (physics-first: meters)
+* All distances and ranges are in meters - no pixel conversions for game logic
+*
+* Each technique has a reachConfig with baseExtension multiplier
+* Applied to archetype's limb length: reach = (limbLength/100) × baseExtension × stanceModifier
+*
+* @korean 기술 범위 시스템 (물리 우선: 미터)
+*/
+/**
+* Get viable techniques based on distance, stance, and stamina
+*
+* Filters techniques that:
+* - Match current stance
+* - Are within effective range of opponent
+* - Have sufficient stamina to execute
+* - Applies selection bias against recently used techniques (avoid >70% repetition)
+*
+* @korean 거리, 자세, 체력에 따른 실행 가능한 기술 선택
+*
+* @param distance - Distance to opponent in meters (physics-first)
+* @param stance - Current trigram stance
+* @param stamina - Available stamina
+* @param archetype - Player archetype for specialized techniques
+* @param recentTechniques - Array of recently used technique IDs (for variation)
+* @returns Array of viable techniques sorted by effectiveness with variation bias
+*/
+function getViableTechniques(distance, stance, stamina, archetype, recentTechniques = []) {
+	const stanceTechniques = KoreanTechniquesSystem.getAllAvailableTechniques(stance, archetype);
+	if (stanceTechniques.length === 0) return [];
+	const viableTechniques = stanceTechniques.filter((tech) => {
+		const physicalAttributes = getArchetypePhysicalAttributes(archetype);
+		const animType = tech.animationType;
+		let maxReach;
+		if (animType) maxReach = physicalReachCalculator.calculateMaxReach(physicalAttributes, animType, stance);
+		else {
+			const limbLength = tech.reachConfig.bodyPart === "leg" ? physicalAttributes.legLength : physicalAttributes.armLength;
+			let bodyPivot;
+			if (tech.reachConfig.bodyPart === "leg") bodyPivot = .25;
+			else bodyPivot = physicalAttributes.shoulderWidth / 2 / 100 + .1;
+			const stanceModifier = STANCE_REACH_MODIFIERS[stance];
+			maxReach = (limbLength / 100 + bodyPivot) * tech.reachConfig.baseExtension * stanceModifier;
+		}
+		const inRange = distance <= maxReach;
+		const hasStamina = stamina >= tech.staminaCost;
+		return inRange && hasStamina;
+	});
+	const recentUseCounts = /* @__PURE__ */ new Map();
+	for (const tech of viableTechniques) recentUseCounts.set(tech.id, recentTechniques.filter((id) => id === tech.id).length);
+	return viableTechniques.sort((a, b) => {
+		const baseEffectivenessA = (a.damage ?? 0) * (a.accuracy ?? .8);
+		const baseEffectivenessB = (b.damage ?? 0) * (b.accuracy ?? .8);
+		const recentUsesA = recentUseCounts.get(a.id) ?? 0;
+		const recentUsesB = recentUseCounts.get(b.id) ?? 0;
+		const penaltyA = Math.min(.6, recentUsesA * .2);
+		const penaltyB = Math.min(.6, recentUsesB * .2);
+		const finalEffectivenessA = baseEffectivenessA * (1 - penaltyA);
+		return baseEffectivenessB * (1 - penaltyB) - finalEffectivenessA;
+	});
+}
+/**
+* Select optimal vital point for attack based on stance compatibility and archetype priority
+*
+* Prioritizes vital points by:
+* 1. Archetype vital target priority (health/pain/consciousness/balanced)
+* 2. Stance compatibility (must be in effectiveStances array)
+* 3. Base damage threshold (>25 damage preferred)
+* 4. Targeting difficulty vs AI skill level
+*
+* @korean 자세 효과 및 원형 우선순위에 따른 최적 급소 선택
+*
+* @param stance - Current trigram stance
+* @param difficultyLevel - AI difficulty level (0.0-1.0)
+* @param archetype - Player archetype for priority targeting
+* @returns Vital point ID or null if no suitable target
+*/
+function selectOptimalVitalPoint(stance, difficultyLevel, archetype) {
+	if (KOREAN_VITAL_POINTS.length === 0) return null;
+	const behavior = getArchetypeBehavior(archetype);
+	const effectivePoints = KOREAN_VITAL_POINTS.filter((point) => point.effectiveStances?.includes(stance));
+	if (effectivePoints.length === 0) return KOREAN_VITAL_POINTS[Math.floor(Math.random() * KOREAN_VITAL_POINTS.length)]?.id ?? null;
+	const HIGH_DAMAGE_THRESHOLD = 25;
+	const highDamagePoints = effectivePoints.filter((point) => (point.baseDamage ?? 0) > HIGH_DAMAGE_THRESHOLD);
+	return [...highDamagePoints.length > 0 ? highDamagePoints : effectivePoints].sort((a, b) => {
+		const baseSuitabilityA = (a.baseDamage ?? 0) * (1 - Math.abs(difficultyLevel - a.targetingDifficulty));
+		const baseSuitabilityB = (b.baseDamage ?? 0) * (1 - Math.abs(difficultyLevel - b.targetingDifficulty));
+		const priorityMultiplierA = getVitalPointPriorityScore(a, behavior.vitalTargetPriority);
+		const priorityMultiplierB = getVitalPointPriorityScore(b, behavior.vitalTargetPriority);
+		const finalSuitabilityA = baseSuitabilityA * priorityMultiplierA;
+		return baseSuitabilityB * priorityMultiplierB - finalSuitabilityA;
+	})[0]?.id ?? null;
+}
+/**
+* Calculate priority score for vital point based on archetype targeting preference
+*
+* @korean 원형 타격 우선순위 점수 계산
+*
+* @param vitalPoint - Vital point to score
+* @param priority - Archetype vital target priority
+* @returns Priority multiplier (1.0 = neutral, >1.0 = preferred, <1.0 = deprioritized)
+*/
+function getVitalPointPriorityScore(vitalPoint, priority) {
+	const effects = vitalPoint.effects ?? [];
+	switch (priority) {
+		case "health": return (vitalPoint.baseDamage ?? 0) > 30 ? 1.5 : 1;
+		case "pain": return effects.some((e) => String(e).toLowerCase().includes("pain") || String(e).toLowerCase().includes("disorientation")) ? 1.5 : 1;
+		case "consciousness": return effects.some((e) => String(e).toLowerCase().includes("unconscious") || String(e).toLowerCase().includes("stun") || String(e).toLowerCase().includes("breathless")) ? 1.5 : 1;
+		default: return 1;
+	}
+}
+/**
+* Check if a technique is a signature move for the given archetype
+*
+* Signature techniques are identified by:
+* - Damage type and attack type matching archetype preferences
+* - Ki/Stamina costs indicating advanced techniques
+* - Specific technique characteristics (e.g., nerve strikes for Amsalja)
+*
+* @korean 원형 대표 기술 확인
+*
+* @param technique - Technique to check
+* @param archetype - Player archetype
+* @returns True if technique is signature for the archetype
+*/
+function isSignatureTechnique(technique, archetype) {
+	const damageType = technique.damageType;
+	const attackType = technique.type;
+	const isAdvanced = (technique.kiCost ?? 0) >= 10 || (technique.staminaCost ?? 0) >= 15;
+	switch (archetype) {
+		case PlayerArchetype.MUSA: return damageType === DamageType.JOINT || damageType === DamageType.CRUSHING || damageType === DamageType.BLUNT && isAdvanced;
+		case PlayerArchetype.AMSALJA: return damageType === DamageType.NERVE || damageType === DamageType.PRESSURE || attackType === CombatAttackType.NERVE_STRIKE || attackType === CombatAttackType.PRESSURE_POINT;
+		case PlayerArchetype.HACKER: return damageType === DamageType.INTERNAL || damageType === DamageType.NERVE || isAdvanced && (technique.accuracy ?? 0) >= .8;
+		case PlayerArchetype.JEONGBO_YOWON: return damageType === DamageType.PRESSURE || damageType === DamageType.JOINT || attackType === CombatAttackType.GRAPPLE;
+		case PlayerArchetype.JOJIK_POKRYEOKBAE: return (technique.damage ?? 0) >= 30 || damageType === DamageType.SLASHING || damageType === DamageType.PIERCING;
+		default: return false;
+	}
+}
+/**
+* Update technique usage frequency and rotation queue
+*
+* Tracks technique usage for diversity enforcement:
+* 1. Updates usage frequency counter
+* 2. Adds to recent techniques queue (last 5)
+* 3. Marks as used in current match
+* 4. Resets "all used" when all 4 archetype techniques completed
+*
+* @korean 기술 사용 빈도 및 순환 큐 업데이트
+*
+* @param techniqueId - ID of technique just used
+* @param rotationQueue - Technique rotation tracking object
+* @param archetypeTechniqueIds - All technique IDs for this archetype (for reset detection)
+*/
+function updateTechniqueRotation(techniqueId, rotationQueue, archetypeTechniqueIds) {
+	const current = rotationQueue.frequency.get(techniqueId) ?? 0;
+	rotationQueue.frequency.set(techniqueId, current + 1);
+	rotationQueue.totalAttacks++;
+	rotationQueue.used.push(techniqueId);
+	if (rotationQueue.used.length > 5) rotationQueue.used.shift();
+	rotationQueue.allUsed.add(techniqueId);
+	let allTechniquesUsed = true;
+	for (const techId of archetypeTechniqueIds) if (!rotationQueue.allUsed.has(techId)) {
+		allTechniquesUsed = false;
+		break;
+	}
+	if (allTechniquesUsed) rotationQueue.allUsed.clear();
+}
+/**
+* Check if technique is overused (exceeds 40% threshold)
+*
+* Enforces variety by identifying techniques that have been
+* used more than 40% of total attacks.
+*
+* @korean 기술 과다 사용 확인 (40% 임계값)
+*
+* @param techniqueId - Technique ID to check
+* @param rotationQueue - Technique rotation tracking object
+* @returns True if technique exceeds 40% usage threshold
+*/
+function isOverused(techniqueId, rotationQueue) {
+	if (rotationQueue.totalAttacks === 0) return false;
+	return (rotationQueue.frequency.get(techniqueId) ?? 0) / rotationQueue.totalAttacks > .4;
+}
+/**
+* Select technique with rotation bias for diversity
+*
+* Prioritizes techniques in this order:
+* 1. Never used in this match (highest priority)
+* 2. Not used in last 5 techniques (avoid repetition)
+* 3. Any viable technique (fallback)
+*
+* Within each priority tier, selects by effectiveness (damage × accuracy).
+*
+* @korean 다양성을 위한 순환 편향 기술 선택
+*
+* @param viableTechniques - Techniques that are viable (range, stamina, stance)
+* @param rotationQueue - Technique rotation tracking object
+* @returns Best technique with rotation bias applied
+*/
+function selectTechniqueWithRotation(viableTechniques, rotationQueue) {
+	if (viableTechniques.length === 0) return;
+	const balancedTechniques = viableTechniques.filter((t) => !isOverused(t.id, rotationQueue));
+	const candidates = balancedTechniques.length > 0 ? balancedTechniques : viableTechniques;
+	if (balancedTechniques.length === 0 && rotationQueue.totalAttacks > 0) {
+		rotationQueue.frequency.clear();
+		rotationQueue.totalAttacks = 0;
+	}
+	const neverUsed = candidates.filter((t) => !rotationQueue.allUsed.has(t.id));
+	if (neverUsed.length > 0) return [...neverUsed].sort((a, b) => {
+		const effA = (a.damage ?? 0) * (a.accuracy ?? .8);
+		return (b.damage ?? 0) * (b.accuracy ?? .8) - effA;
+	})[0];
+	const unusedRecently = candidates.filter((t) => !rotationQueue.used.includes(t.id));
+	if (unusedRecently.length > 0) return [...unusedRecently].sort((a, b) => {
+		const effA = (a.damage ?? 0) * (a.accuracy ?? .8);
+		return (b.damage ?? 0) * (b.accuracy ?? .8) - effA;
+	})[0];
+	return [...candidates].sort((a, b) => {
+		const effA = (a.damage ?? 0) * (a.accuracy ?? .8);
+		return (b.damage ?? 0) * (b.accuracy ?? .8) - effA;
+	})[0];
+}
+/**
+* Filter techniques by cooldown availability
+*
+* Returns only techniques that are off cooldown and ready to use.
+* If all techniques are on cooldown, returns empty array.
+*
+* @korean 재사용 대기시간별 기술 필터링
+*
+* @param techniques - Techniques to filter
+* @param cooldownMap - Map of technique ID to last use timestamp
+* @returns Techniques that are off cooldown
+*/
+function filterByCooldown(techniques, cooldownMap) {
+	const now = Date.now();
+	return techniques.filter((t) => {
+		const lastUsed = cooldownMap.get(t.id) ?? 0;
+		const cooldown = (t.recoveryTime ?? 0) + (t.executionTime ?? 0);
+		return now - lastUsed >= cooldown;
+	});
+}
+/**
+* Get all techniques for an archetype (for cross-stance usage)
+*
+* Returns all 4 techniques available to the archetype,
+* regardless of stance requirements.
+*
+* @korean 원형의 모든 기술 가져오기 (교차 자세 사용)
+*
+* @param archetype - Player archetype
+* @returns All techniques for the archetype
+*/
+function getAllArchetypeTechniques(archetype) {
+	return KoreanTechniquesSystem.getTechniquesByArchetype(archetype);
+}
+/**
+* Apply cross-stance damage modifier to technique
+*
+* Creates a modified copy of the technique with 80% damage for cross-stance usage.
+* This prevents mutation of the original technique object.
+*
+* **Design Rationale for 80% Effectiveness:**
+* Cross-stance techniques are performed from a non-optimal stance, reducing
+* power generation and body mechanics efficiency. The 80% modifier reflects:
+* - Suboptimal weight transfer and leverage
+* - Reduced muscle engagement from non-ideal positioning
+* - Decreased stability and balance during execution
+*
+* This is consistent with Korean martial arts philosophy where proper stance
+* (자세) is fundamental to technique effectiveness. Other properties like
+* accuracy and execution time remain unchanged as the technique mechanics
+* themselves are unchanged, only the power generation is affected.
+*
+* @korean 교차 자세 피해 배율 적용 (80% 효과)
+*
+* @param technique - Original technique
+* @param isCrossStance - Whether technique is from different stance
+* @returns Modified technique with 80% damage if cross-stance, original otherwise
+*/
+function applyCrossStanceDamageModifier(technique, isCrossStance) {
+	if (!isCrossStance || !technique.damage) return technique;
+	return {
+		...technique,
+		damage: Math.floor(technique.damage * .8)
+	};
+}
+/**
+* Helper to select technique for AI action with rotation and cooldown awareness
+*
+* Enhanced technique selection with:
+* - Technique rotation queue for diversity (prevents >70% repetition → targets <40%)
+* - Cooldown-aware filtering (prioritizes ready techniques)
+* - Cross-stance fallback (uses other techniques at 80% effectiveness)
+* - Archetype signature bias (maintains 40%+ signature technique usage)
+*
+* @korean 순환 및 재사용 대기시간을 고려한 기술 선택
+*
+* @param isSpecialTechnique - Whether to filter for high-cost special techniques
+* @param context - Current combat context
+* @param player - AI player state
+* @param adaptiveDifficulty - Adaptive difficulty system
+* @param rotationQueue - Technique rotation tracking object
+* @param cooldownMap - Technique cooldown tracking map
+* @returns Selected technique, vital point, action type, and cross-stance flag
+*/
+function selectTechniqueForAction(isSpecialTechnique, context, player, adaptiveDifficulty, rotationQueue, cooldownMap) {
+	if (shouldExecuteSignatureMove(player.archetype, context)) {
+		const signatureMoveId = getSignatureMove(player.archetype);
+		const signatureTechnique = getAllArchetypeTechniques(player.archetype).find((t) => t.id === signatureMoveId);
+		if (signatureTechnique) {
+			const now = Date.now();
+			const lastUsed = cooldownMap.get(signatureMoveId) ?? 0;
+			const techniqueCooldown = (signatureTechnique.recoveryTime ?? 0) + (signatureTechnique.executionTime ?? 0);
+			if (Math.max(0, techniqueCooldown - (now - lastUsed)) === 0 && player.stamina >= signatureTechnique.staminaCost && player.ki >= signatureTechnique.kiCost) {
+				console.log(`[AI] Executing signature move: ${signatureMoveId} for ${player.archetype}`);
+				const difficultyLevel = adaptiveDifficulty.calculatePlayerSkill();
+				return {
+					technique: signatureTechnique,
+					vitalPoint: selectOptimalVitalPoint(player.currentStance, difficultyLevel, player.archetype) ?? void 0,
+					actionType: "signature_move",
+					isCrossStance: signatureTechnique.stance !== player.currentStance
+				};
+			}
+		}
+	}
+	const viableTechniques = getViableTechniques(context.distanceToOpponent, player.currentStance, player.stamina, player.archetype, rotationQueue.used);
+	const readyTechniques = filterByCooldown(viableTechniques, cooldownMap);
+	let candidates = readyTechniques.length > 0 ? readyTechniques : viableTechniques;
+	if (isSpecialTechnique) {
+		const specialCandidates = candidates.filter((tech) => tech.kiCost >= 10 || tech.staminaCost >= 15);
+		candidates = specialCandidates.length > 0 ? specialCandidates : candidates;
+	}
+	let isCrossStance = false;
+	if (candidates.length === 0) {
+		const crossStanceTechniques = getAllArchetypeTechniques(player.archetype).filter((t) => t.stance !== player.currentStance && context.distanceToOpponent <= (t.reachConfig?.baseExtension ?? 1) && player.stamina >= t.staminaCost && !isOverused(t.id, rotationQueue));
+		const readyCrossStance = filterByCooldown(crossStanceTechniques, cooldownMap);
+		candidates = readyCrossStance.length > 0 ? readyCrossStance : crossStanceTechniques;
+		isCrossStance = candidates.length > 0;
+	}
+	if (candidates.length > 0) {
+		const signatureTechniques = candidates.filter((tech) => isSignatureTechnique(tech, player.archetype));
+		const technique = selectTechniqueWithRotation(signatureTechniques.length > 0 && Math.random() < .6 ? signatureTechniques : candidates, rotationQueue);
+		if (technique) {
+			const difficultyLevel = adaptiveDifficulty.calculatePlayerSkill();
+			const vitalPoint = selectOptimalVitalPoint(player.currentStance, difficultyLevel, player.archetype) ?? void 0;
+			return {
+				technique: applyCrossStanceDamageModifier(technique, isCrossStance),
+				vitalPoint,
+				actionType: isSpecialTechnique ? "technique" : "attack",
+				isCrossStance
+			};
+		}
+	}
+	return { actionType: "idle" };
+}
+/**
+* Determine if AI should switch stance laterality based on personality and tactical situation.
+*
+* Strategic laterality decisions in Korean martial arts:
+* - **Aggressive personality**: Prefers matched stances (same laterality) for offensive advantage
+*   Matched stances expose centerlines, creating attack opportunities
+* - **Defensive personality**: Prefers mismatched stances (opposite laterality) for protection
+*   Mismatched stances naturally guard centerlines with lead hand
+* - **Health-based modifier**: Low health increases defensive preference
+*
+* @param aiLaterality - AI's current stance laterality
+* @param opponentLaterality - Opponent's stance laterality
+* @param personality - AI personality archetype
+* @param aiHealth - AI's current health (0-100)
+* @param lastSwitchTime - Timestamp of last laterality switch
+* @param currentTime - Current timestamp for cooldown check
+* @returns true if AI should switch laterality, false otherwise
+*
+* @korean AI 측면성 전환 결정
+*/
+function shouldAISwitchLaterality(aiLaterality, opponentLaterality, personality, aiHealth, lastSwitchTime, currentTime) {
+	if (currentTime - lastSwitchTime < 3e3) return false;
+	const isMatched = aiLaterality === opponentLaterality;
+	const aggressionFactor = personality.aggressionLevel;
+	const defenseFactor = personality.defensePreference;
+	const healthFactor = aiHealth / 100;
+	const effectiveAggression = aggressionFactor * Math.max(.3, healthFactor);
+	const effectiveDefense = defenseFactor * (1.2 - healthFactor * .2);
+	if (effectiveAggression > .6 && !isMatched) return Math.random() < .3;
+	if (effectiveDefense > .6 && isMatched) return Math.random() < .25;
+	if (aiHealth < 30 && isMatched) return Math.random() < .4;
+	return false;
+}
+/**
+* Custom hook for AI combat behavior
+*/
+function useAICombat(config) {
+	const { player, opponent, personality, adaptiveDifficulty, isPaused, roundStarted, roundEnded, arenaBounds, onExecuteAction, onStanceChange, onLateralityChange, playerLaterality, opponentLaterality } = config;
+	const comboSystem = useMemo(() => new AIComboSystem(), []);
+	const decisionTree = useMemo(() => new AIDecisionTree(), []);
+	const adjustedPersonality = useMemo(() => adaptiveDifficulty.adjustAIPersonality(personality), [adaptiveDifficulty, personality]);
+	const lastSkillLevelRef = useRef(.5);
+	useEffect(() => {
+		const newSkillLevel = adaptiveDifficulty.calculatePlayerSkill();
+		if (Math.abs(newSkillLevel - lastSkillLevelRef.current) > .01) {
+			lastSkillLevelRef.current = newSkillLevel;
+			decisionTree.setDifficultyLevel(newSkillLevel);
+		}
+	}, [adaptiveDifficulty, decisionTree]);
+	const [currentParams, setCurrentParams] = useState(() => adaptiveDifficulty.getDifficultyParameters());
+	const [targetParams, setTargetParams] = useState(() => adaptiveDifficulty.getDifficultyParameters());
+	const startParamsRef = useRef(currentParams);
+	const transitionStartTimeRef = useRef(0);
+	const transitionDurationMs = 1e4;
+	const [aiState, setAiState] = useState(() => {
+		return {
+			nextAction: Date.now(),
+			targetPosition: player.position,
+			lastActionType: "idle",
+			consecutiveAttacks: 0,
+			actionCooldown: 500,
+			aggressionLevel: adjustedPersonality.aggressionLevel,
+			selectedTechnique: void 0,
+			targetVitalPoint: void 0,
+			recentTechniques: []
+		};
+	});
+	const lastDecisionTimeRef = useRef(0);
+	const [initialMatchTime] = useState(() => Date.now());
+	const matchStartTimeRef = useRef(initialMatchTime);
+	const previousDamageRef = useRef(0);
+	const [initialActionTime] = useState(() => Date.now());
+	const nextActionRef = useRef(initialActionTime);
+	const lastWarningTimeRef = useRef(0);
+	const lastLateralitySwitchRef = useRef(0);
+	const techniqueRotationQueueRef = useRef({
+		used: [],
+		allUsed: /* @__PURE__ */ new Set(),
+		frequency: /* @__PURE__ */ new Map(),
+		totalAttacks: 0
+	});
+	const techniqueCooldownMapRef = useRef(/* @__PURE__ */ new Map());
+	const archetypeTechniqueIds = useMemo(() => {
+		const allTechs = getAllArchetypeTechniques(player.archetype);
+		return new Set(allTechs.map((t) => t.id));
+	}, [player.archetype]);
+	const [initialStanceFatigue] = useState(() => ({
+		currentStance: player.currentStance,
+		lastSwitchTime: Date.now()
+	}));
+	const stanceFatigueRef = useRef(initialStanceFatigue);
+	useEffect(() => {
+		if (roundStarted) {
+			matchStartTimeRef.current = Date.now();
+			previousDamageRef.current = player.totalDamageReceived;
+			decisionTree.reset();
+			comboSystem.resetCombo();
+			stanceFatigueRef.current = {
+				currentStance: player.currentStance,
+				lastSwitchTime: Date.now()
+			};
+			techniqueRotationQueueRef.current = {
+				used: [],
+				allUsed: /* @__PURE__ */ new Set(),
+				frequency: /* @__PURE__ */ new Map(),
+				totalAttacks: 0
+			};
+			techniqueCooldownMapRef.current.clear();
+		}
+	}, [
+		roundStarted,
+		decisionTree,
+		comboSystem
+	]);
+	useEffect(() => {
+		if (!roundStarted || roundEnded || isPaused) return;
+		if (player.currentStance !== stanceFatigueRef.current.currentStance) stanceFatigueRef.current = {
+			currentStance: player.currentStance,
+			lastSwitchTime: Date.now()
+		};
+	}, [
+		player.currentStance,
+		roundStarted,
+		roundEnded,
+		isPaused
+	]);
+	useEffect(() => {
+		if (isPaused || !roundStarted || roundEnded) return;
+		let animationFrameId;
+		let isComplete = false;
+		const animate = () => {
+			if (isComplete) return;
+			const elapsed = Date.now() - transitionStartTimeRef.current;
+			const progress = Math.min(1, elapsed / transitionDurationMs);
+			if (progress < 1) {
+				setCurrentParams(interpolateDifficultyParameters(startParamsRef.current, targetParams, progress));
+				animationFrameId = requestAnimationFrame(animate);
+			} else {
+				setCurrentParams(targetParams);
+				isComplete = true;
+			}
+		};
+		animationFrameId = requestAnimationFrame(animate);
+		return () => {
+			if (animationFrameId) cancelAnimationFrame(animationFrameId);
+		};
+	}, [
+		isPaused,
+		roundStarted,
+		roundEnded,
+		targetParams,
+		transitionDurationMs
+	]);
+	useEffect(() => {
+		decisionTree.setDifficultyParameters(currentParams);
+	}, [decisionTree, currentParams]);
+	/**
+	* Execute AI action callback
+	*
+	* Passes technique and vital point directly to avoid React state async issues
+	*
+	* @korean AI 행동 실행 콜백
+	*/
+	const executeAIAction = useCallback((action, targetPosition, selectedTechnique, targetVitalPoint) => {
+		onExecuteAction(action, targetPosition, selectedTechnique, targetVitalPoint);
+	}, [onExecuteAction]);
+	/**
+	* Update difficulty target parameters
+	* Triggers smooth interpolation to new difficulty level
+	*
+	* @korean 난이도 목표 매개변수 업데이트
+	*/
+	const updateDifficultyTarget = useCallback((newParams) => {
+		startParamsRef.current = currentParams;
+		transitionStartTimeRef.current = Date.now();
+		setTargetParams(newParams);
+	}, [currentParams]);
+	/**
+	* Build combat context for decision-making.
+	*
+	* **Physics-first**: Positions are now in METERS, so distance is already in meters.
+	* No scale conversion needed - direct physics-based calculations.
+	*
+	* @korean 전투 컨텍스트 구축
+	*/
+	const buildCombatContext = useCallback(() => {
+		const dx = player.position.x - opponent.position.x;
+		const dy = player.position.y - opponent.position.y;
+		const distanceInMeters = Math.sqrt(dx * dx + dy * dy);
+		const recentDamageTaken = Math.max(0, player.totalDamageReceived - previousDamageRef.current);
+		previousDamageRef.current = player.totalDamageReceived;
+		const opponentBalance = getBalanceState(opponent.balance);
+		return {
+			playerPosition: player.position,
+			opponentPosition: opponent.position,
+			playerHealth: player.health,
+			playerMaxHealth: player.maxHealth,
+			playerKi: player.ki,
+			playerMaxKi: player.maxKi,
+			playerStamina: player.stamina,
+			playerMaxStamina: player.maxStamina,
+			opponentHealth: opponent.health,
+			opponentStance: opponent.currentStance,
+			playerStance: player.currentStance,
+			distanceToOpponent: distanceInMeters,
+			timeInMatch: Date.now() - matchStartTimeRef.current,
+			isOpponentAttacking: opponent.combatState === "attacking",
+			recentDamageTaken,
+			opponentBalance,
+			opponentStamina: opponent.stamina,
+			opponentMaxStamina: opponent.maxStamina,
+			opponentKi: opponent.ki,
+			opponentMaxKi: opponent.maxKi,
+			stanceFatigue: { timeInStance: Date.now() - stanceFatigueRef.current.lastSwitchTime },
+			arenaBounds
+		};
+	}, [
+		player,
+		opponent,
+		arenaBounds
+	]);
+	/**
+	* AI decision loop (fixed memory leak - issue #2529466989)
+	*/
+	useEffect(() => {
+		if (isPaused || !roundStarted || roundEnded) return;
+		const aiInterval = setInterval(() => {
+			const now = Date.now();
+			if (now < nextActionRef.current) return;
+			const decisionStart = performance.now();
+			const context = buildCombatContext();
+			const decision = decisionTree.makeDecision(context, adjustedPersonality, comboSystem);
+			const decisionTime = performance.now() - decisionStart;
+			if (decisionTime > AI_DECISION_THRESHOLD_MS) {
+				const now = Date.now();
+				if (now - lastWarningTimeRef.current > WARNING_THROTTLE_MS) {
+					console.warn(`AI decisions running slow: ${decisionTime.toFixed(2)}ms`);
+					lastWarningTimeRef.current = now;
+				}
+			}
+			lastDecisionTimeRef.current = decisionTime;
+			let actionType = "idle";
+			let newTargetPosition = aiState.targetPosition;
+			let newConsecutiveAttacks = aiState.consecutiveAttacks;
+			let selectedTechnique;
+			let targetVitalPoint;
+			switch (decision.action) {
+				case AIActionType.ATTACK:
+					{
+						const result = selectTechniqueForAction(false, context, player, adaptiveDifficulty, techniqueRotationQueueRef.current, techniqueCooldownMapRef.current);
+						selectedTechnique = result.technique;
+						targetVitalPoint = result.vitalPoint;
+						actionType = result.actionType;
+						if (selectedTechnique) {
+							updateTechniqueRotation(selectedTechnique.id, techniqueRotationQueueRef.current, archetypeTechniqueIds);
+							techniqueCooldownMapRef.current.set(selectedTechnique.id, Date.now());
+							if (getNextComboTechnique(selectedTechnique.id, player.archetype)) comboSystem.startCombo(player, opponent, adjustedPersonality);
+						}
+						if (actionType === "attack") newConsecutiveAttacks++;
+					}
+					break;
+				case AIActionType.TECHNIQUE:
+					{
+						const result = selectTechniqueForAction(true, context, player, adaptiveDifficulty, techniqueRotationQueueRef.current, techniqueCooldownMapRef.current);
+						selectedTechnique = result.technique;
+						targetVitalPoint = result.vitalPoint;
+						actionType = result.actionType;
+						if (selectedTechnique) {
+							updateTechniqueRotation(selectedTechnique.id, techniqueRotationQueueRef.current, archetypeTechniqueIds);
+							techniqueCooldownMapRef.current.set(selectedTechnique.id, Date.now());
+							if (getNextComboTechnique(selectedTechnique.id, player.archetype)) comboSystem.startCombo(player, opponent, adjustedPersonality);
+						}
+						if (actionType === "attack" || actionType === "technique") newConsecutiveAttacks++;
+					}
+					break;
+				case AIActionType.COMBO:
+					if (!comboSystem.isComboActive()) comboSystem.startCombo(player, opponent, adjustedPersonality);
+					if (comboSystem.shouldContinueCombo(player, opponent, adjustedPersonality)) {
+						actionType = comboSystem.getNextComboTechnique() ? "technique" : "attack";
+						newConsecutiveAttacks++;
+					} else {
+						comboSystem.resetCombo();
+						actionType = "idle";
+					}
+					break;
+				case AIActionType.DEFEND:
+					actionType = "defend";
+					newConsecutiveAttacks = 0;
+					break;
+				case AIActionType.COUNTER:
+					actionType = "counter";
+					newConsecutiveAttacks = 0;
+					break;
+				case AIActionType.RETREAT:
+					actionType = "retreat";
+					newTargetPosition = decision.targetPosition ?? aiState.targetPosition;
+					newConsecutiveAttacks = 0;
+					break;
+				case AIActionType.APPROACH:
+					actionType = "approach";
+					newTargetPosition = decision.targetPosition ?? opponent.position;
+					newConsecutiveAttacks = 0;
+					break;
+				case AIActionType.CIRCLE:
+					actionType = "circle";
+					newTargetPosition = decision.targetPosition ?? aiState.targetPosition;
+					newConsecutiveAttacks = 0;
+					break;
+				case AIActionType.STANCE_CHANGE:
+					if (decision.targetStance && onStanceChange) onStanceChange(decision.targetStance);
+					actionType = "idle";
+					newConsecutiveAttacks = 0;
+					break;
+				case AIActionType.FEINT:
+					actionType = "feint";
+					newConsecutiveAttacks = 0;
+					break;
+				case AIActionType.WAIT:
+				default:
+					actionType = "idle";
+					newConsecutiveAttacks = 0;
+					break;
+			}
+			if (onLateralityChange && playerLaterality && opponentLaterality) {
+				if (shouldAISwitchLaterality(opponentLaterality, playerLaterality, adjustedPersonality, player.health, lastLateralitySwitchRef.current, now)) {
+					onLateralityChange();
+					lastLateralitySwitchRef.current = now;
+				}
+			}
+			const actionCooldown = actionType === "attack" || actionType === "technique" ? 200 + Math.random() * 150 : 150 + Math.random() * 150;
+			nextActionRef.current = now + actionCooldown;
+			setAiState((prevState) => {
+				let updatedRecentTechniques = [...prevState.recentTechniques];
+				if (selectedTechnique) {
+					updatedRecentTechniques.push(selectedTechnique.id);
+					if (updatedRecentTechniques.length > 5) updatedRecentTechniques = updatedRecentTechniques.slice(-5);
+				}
+				return {
+					nextAction: nextActionRef.current,
+					targetPosition: newTargetPosition,
+					lastActionType: actionType,
+					consecutiveAttacks: newConsecutiveAttacks,
+					actionCooldown,
+					aggressionLevel: adjustedPersonality.aggressionLevel,
+					selectedTechnique,
+					targetVitalPoint,
+					recentTechniques: updatedRecentTechniques
+				};
+			});
+			executeAIAction(actionType, newTargetPosition, selectedTechnique, targetVitalPoint);
+		}, 50);
+		return () => clearInterval(aiInterval);
+	}, [
+		isPaused,
+		roundStarted,
+		roundEnded,
+		buildCombatContext,
+		decisionTree,
+		adjustedPersonality,
+		comboSystem,
+		executeAIAction,
+		onStanceChange,
+		onLateralityChange,
+		player,
+		opponent,
+		aiState,
+		playerLaterality,
+		opponentLaterality,
+		adaptiveDifficulty,
+		archetypeTechniqueIds
+	]);
+	return {
+		aiState,
+		comboSystem,
+		decisionTree,
+		adjustedPersonality,
+		executeAIAction,
+		currentDifficultyParams: currentParams,
+		updateDifficultyTarget
+	};
+}
+//#endregion
+export { useAICombat };
+
+//# sourceMappingURL=useAICombat.js.map