blacktrigram 0.7.2

package/lib/systems/ai/TrainingAI.js

@@ -0,0 +1,265 @@
+import { TrigramStance } from "../../types/common.js";
+import "../../types/index.js";
+import { AI_PERSONALITIES } from "./AIPersonality.js";
+import { AIComboSystem } from "./ComboSystem.js";
+import { AdaptiveDifficulty } from "./AdaptiveDifficulty.js";
+import { AIDecisionTree } from "./DecisionTree.js";
+//#region src/systems/ai/TrainingAI.ts
+/**
+* TrainingAI - AI opponent system for training mode
+*
+* Integrates AIPersonality, DecisionTree, and ComboSystem to create
+* a configurable AI opponent for training scenarios.
+*
+* **Korean Philosophy (훈련 AI 철학)**:
+* - 단계적 난이도 (Stepped Difficulty): Progressive challenge levels
+* - 교육적 피드백 (Educational Feedback): AI teaches through behavior
+* - 적응형 전투 (Adaptive Combat): AI adjusts to player skill
+*/
+var DIFFICULTY_CONFIGS = {
+	easy: {
+		reactionTime: 500,
+		blockChance: .3,
+		counterChance: .1,
+		aggressionMultiplier: .6,
+		aiSkillLevel: .3
+	},
+	medium: {
+		reactionTime: 300,
+		blockChance: .5,
+		counterChance: .3,
+		aggressionMultiplier: .8,
+		aiSkillLevel: .6
+	},
+	hard: {
+		reactionTime: 150,
+		blockChance: .7,
+		counterChance: .5,
+		aggressionMultiplier: 1,
+		aiSkillLevel: .9
+	}
+};
+/**
+* TrainingAI System
+*
+* Manages AI opponent behavior in training mode using existing AI systems.
+* Provides configurable difficulty and realistic martial arts behavior.
+*/
+var TrainingAI = class {
+	state;
+	decisionTree;
+	comboSystem;
+	adaptiveDifficulty;
+	actionDelayTimer = 0;
+	constructor(difficulty = "medium", initialPosition = {
+		x: 5,
+		y: 0
+	}, personalityKey) {
+		const personality = personalityKey ? AI_PERSONALITIES[personalityKey] ?? AI_PERSONALITIES.BALANCED_FIGHTER : this.selectPersonalityForDifficulty(difficulty);
+		const config = DIFFICULTY_CONFIGS[difficulty];
+		this.state = {
+			difficulty,
+			personality,
+			currentAction: null,
+			position: initialPosition,
+			stance: personality.favoredStances[0] ?? TrigramStance.GEON,
+			isActive: false,
+			reactionTime: config.reactionTime,
+			blockChance: config.blockChance,
+			counterChance: config.counterChance,
+			lastActionTime: 0
+		};
+		this.decisionTree = new AIDecisionTree();
+		this.decisionTree.setDifficultyLevel(config.aiSkillLevel);
+		this.comboSystem = new AIComboSystem();
+		this.adaptiveDifficulty = new AdaptiveDifficulty();
+	}
+	/**
+	* Select appropriate personality for difficulty level
+	*/
+	selectPersonalityForDifficulty(difficulty) {
+		switch (difficulty) {
+			case "easy": return AI_PERSONALITIES.DEFENSIVE_SPECIALIST;
+			case "medium": return AI_PERSONALITIES.BALANCED_FIGHTER;
+			case "hard": return AI_PERSONALITIES.AGGRESSIVE_STRIKER;
+			default: return AI_PERSONALITIES.BALANCED_FIGHTER;
+		}
+	}
+	/**
+	* Activate AI opponent
+	*/
+	activate() {
+		this.state = {
+			...this.state,
+			isActive: true,
+			lastActionTime: Date.now()
+		};
+	}
+	/**
+	* Deactivate AI opponent
+	*/
+	deactivate() {
+		this.state = {
+			...this.state,
+			isActive: false,
+			currentAction: null
+		};
+	}
+	/**
+	* Update AI behavior (60fps game loop)
+	*
+	* Internal method called each frame by the TrainingAI system to process AI decision-making and update state.
+	* Respects reaction time delays based on difficulty level.
+	*
+	* @param deltaTime - Time since last frame in seconds
+	* @param playerState - Current player state
+	* @param aiPlayerState - Current AI player state (for combat systems)
+	* @returns Updated AI decision or null if inactive/delayed
+	*/
+	update(deltaTime, playerState, aiPlayerState) {
+		if (!this.state.isActive) return null;
+		const now = Date.now();
+		this.actionDelayTimer = Math.max(0, this.actionDelayTimer - deltaTime * 1e3);
+		if (this.actionDelayTimer > 0) return this.state.currentAction;
+		const context = {
+			playerPosition: this.state.position,
+			opponentPosition: playerState.position,
+			playerHealth: aiPlayerState.health,
+			playerMaxHealth: aiPlayerState.maxHealth,
+			playerKi: aiPlayerState.ki,
+			playerMaxKi: aiPlayerState.maxKi,
+			playerStamina: aiPlayerState.stamina,
+			playerMaxStamina: aiPlayerState.maxStamina,
+			opponentHealth: playerState.health,
+			opponentStance: playerState.currentStance,
+			playerStance: this.state.stance,
+			distanceToOpponent: this.calculateDistance(this.state.position, playerState.position),
+			timeInMatch: (now - this.state.lastActionTime) / 1e3,
+			isOpponentAttacking: this.isPlayerAttacking(playerState),
+			recentDamageTaken: aiPlayerState.totalDamageReceived,
+			arenaBounds: {
+				x: -8,
+				y: -6,
+				width: 16,
+				height: 12,
+				worldWidthMeters: 10,
+				worldDepthMeters: 7.5
+			}
+		};
+		const adjustedPersonality = this.adjustPersonalityForTraining(this.state.personality);
+		const decision = this.decisionTree.makeDecision(context, adjustedPersonality, this.comboSystem);
+		this.actionDelayTimer = this.state.reactionTime;
+		this.state = {
+			...this.state,
+			currentAction: decision,
+			lastActionTime: now
+		};
+		return decision;
+	}
+	/**
+	* Adjust personality based on training context
+	*/
+	adjustPersonalityForTraining(basePersonality) {
+		const config = DIFFICULTY_CONFIGS[this.state.difficulty];
+		return {
+			...basePersonality,
+			aggressionLevel: basePersonality.aggressionLevel * config.aggressionMultiplier,
+			defensePreference: basePersonality.defensePreference * (2 - config.aggressionMultiplier)
+		};
+	}
+	/**
+	* Calculate distance between two positions
+	*/
+	calculateDistance(pos1, pos2) {
+		const dx = pos2.x - pos1.x;
+		const dy = pos2.y - pos1.y;
+		return Math.sqrt(dx * dx + dy * dy);
+	}
+	/**
+	* Determine if player is currently attacking
+	*/
+	isPlayerAttacking(playerState) {
+		return Date.now() - playerState.lastActionTime < 500;
+	}
+	/**
+	* Update AI position (for movement actions)
+	*/
+	updatePosition(newPosition) {
+		this.state = {
+			...this.state,
+			position: newPosition
+		};
+	}
+	/**
+	* Update AI stance
+	*/
+	updateStance(newStance) {
+		this.state = {
+			...this.state,
+			stance: newStance
+		};
+	}
+	/**
+	* Set difficulty
+	*/
+	setDifficulty(difficulty) {
+		const config = DIFFICULTY_CONFIGS[difficulty];
+		const personality = this.selectPersonalityForDifficulty(difficulty);
+		this.state = {
+			...this.state,
+			difficulty,
+			personality,
+			reactionTime: config.reactionTime,
+			blockChance: config.blockChance,
+			counterChance: config.counterChance
+		};
+		this.decisionTree.setDifficultyLevel(config.aiSkillLevel);
+	}
+	/**
+	* Reset AI state
+	*/
+	reset() {
+		this.decisionTree.reset();
+		this.comboSystem.resetCombo();
+		this.actionDelayTimer = 0;
+		this.state = {
+			...this.state,
+			currentAction: null,
+			lastActionTime: Date.now()
+		};
+	}
+	/**
+	* Get current AI state (for display/debugging)
+	*/
+	getState() {
+		return this.state;
+	}
+	/**
+	* Check if AI should block incoming attack
+	*/
+	shouldBlock() {
+		return Math.random() < this.state.blockChance;
+	}
+	/**
+	* Check if AI should counter incoming attack
+	*/
+	shouldCounter() {
+		return Math.random() < this.state.counterChance;
+	}
+	/**
+	* Get AI's current decision for debugging
+	*/
+	getCurrentDecision() {
+		return this.state.currentAction;
+	}
+	/**
+	* Update adaptive difficulty based on match performance
+	*/
+	updateAdaptiveDifficulty(matchData) {
+		this.adaptiveDifficulty.updateSkillMetrics(matchData);
+	}
+};
+//#endregion
+export { TrainingAI as default };
+
+//# sourceMappingURL=TrainingAI.js.map

package/lib/systems/ai/TrainingAI.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TrainingAI.js","names":[],"sources":["../../../src/systems/ai/TrainingAI.ts"],"sourcesContent":["/**\n * TrainingAI - AI opponent system for training mode\n *\n * Integrates AIPersonality, DecisionTree, and ComboSystem to create\n * a configurable AI opponent for training scenarios.\n *\n * **Korean Philosophy (훈련 AI 철학)**:\n * - 단계적 난이도 (Stepped Difficulty): Progressive challenge levels\n * - 교육적 피드백 (Educational Feedback): AI teaches through behavior\n * - 적응형 전투 (Adaptive Combat): AI adjusts to player skill\n */\n\nimport { Position, TrigramStance } from \"@/types\";\nimport { PlayerState } from \"../player\";\nimport { AdaptiveDifficulty } from \"./AdaptiveDifficulty\";\nimport { AIPersonality, AI_PERSONALITIES } from \"./AIPersonality\";\nimport { AIComboSystem } from \"./ComboSystem\";\nimport { AIDecision, AIDecisionTree, CombatContext } from \"./DecisionTree\";\n\n/**\n * Training AI difficulty levels\n */\nexport type AITrainingDifficulty = \"easy\" | \"medium\" | \"hard\";\n\n/**\n * Training AI state\n */\nexport interface TrainingAIState {\n  readonly difficulty: AITrainingDifficulty;\n  readonly personality: AIPersonality;\n  readonly currentAction: AIDecision | null;\n  readonly position: Position;\n  readonly stance: TrigramStance;\n  readonly isActive: boolean;\n  readonly reactionTime: number; // ms delay before responding\n  readonly blockChance: number; // 0.0-1.0\n  readonly counterChance: number; // 0.0-1.0\n  readonly lastActionTime: number;\n}\n\n/**\n * Training AI configuration based on difficulty\n */\ninterface DifficultyConfig {\n  readonly reactionTime: number;\n  readonly blockChance: number;\n  readonly counterChance: number;\n  readonly aggressionMultiplier: number;\n  readonly aiSkillLevel: number; // For DecisionTree\n}\n\nconst DIFFICULTY_CONFIGS: Record<AITrainingDifficulty, DifficultyConfig> = {\n  easy: {\n    reactionTime: 500, // 500ms reaction delay\n    blockChance: 0.3,\n    counterChance: 0.1,\n    aggressionMultiplier: 0.6,\n    aiSkillLevel: 0.3,\n  },\n  medium: {\n    reactionTime: 300, // 300ms reaction delay\n    blockChance: 0.5,\n    counterChance: 0.3,\n    aggressionMultiplier: 0.8,\n    aiSkillLevel: 0.6,\n  },\n  hard: {\n    reactionTime: 150, // 150ms reaction delay\n    blockChance: 0.7,\n    counterChance: 0.5,\n    aggressionMultiplier: 1.0,\n    aiSkillLevel: 0.9,\n  },\n};\n\n/**\n * TrainingAI System\n *\n * Manages AI opponent behavior in training mode using existing AI systems.\n * Provides configurable difficulty and realistic martial arts behavior.\n */\nexport class TrainingAI {\n  private state: TrainingAIState;\n  private decisionTree: AIDecisionTree;\n  private comboSystem: AIComboSystem;\n  private adaptiveDifficulty: AdaptiveDifficulty;\n  private actionDelayTimer: number = 0;\n\n  constructor(\n    difficulty: AITrainingDifficulty = \"medium\",\n    initialPosition: Position = { x: 5, y: 0 },\n    personalityKey?: string,\n  ) {\n    // Select personality based on difficulty or use provided key\n    const personality = personalityKey\n      ? (AI_PERSONALITIES[personalityKey] ?? AI_PERSONALITIES.BALANCED_FIGHTER)\n      : this.selectPersonalityForDifficulty(difficulty);\n\n    const config = DIFFICULTY_CONFIGS[difficulty];\n\n    this.state = {\n      difficulty,\n      personality,\n      currentAction: null,\n      position: initialPosition,\n      stance: personality.favoredStances[0] ?? TrigramStance.GEON,\n      isActive: false,\n      reactionTime: config.reactionTime,\n      blockChance: config.blockChance,\n      counterChance: config.counterChance,\n      lastActionTime: 0,\n    };\n\n    // Initialize AI systems\n    this.decisionTree = new AIDecisionTree();\n    this.decisionTree.setDifficultyLevel(config.aiSkillLevel);\n\n    this.comboSystem = new AIComboSystem();\n    this.adaptiveDifficulty = new AdaptiveDifficulty();\n  }\n\n  /**\n   * Select appropriate personality for difficulty level\n   */\n  private selectPersonalityForDifficulty(\n    difficulty: AITrainingDifficulty,\n  ): AIPersonality {\n    switch (difficulty) {\n      case \"easy\":\n        return AI_PERSONALITIES.DEFENSIVE_SPECIALIST; // Less aggressive\n      case \"medium\":\n        return AI_PERSONALITIES.BALANCED_FIGHTER; // Balanced approach\n      case \"hard\":\n        return AI_PERSONALITIES.AGGRESSIVE_STRIKER; // More aggressive\n      default:\n        return AI_PERSONALITIES.BALANCED_FIGHTER;\n    }\n  }\n\n  /**\n   * Activate AI opponent\n   */\n  activate(): void {\n    this.state = {\n      ...this.state,\n      isActive: true,\n      lastActionTime: Date.now(),\n    };\n  }\n\n  /**\n   * Deactivate AI opponent\n   */\n  deactivate(): void {\n    this.state = {\n      ...this.state,\n      isActive: false,\n      currentAction: null,\n    };\n  }\n\n  /**\n   * Update AI behavior (60fps game loop)\n   *\n   * Internal method called each frame by the TrainingAI system to process AI decision-making and update state.\n   * Respects reaction time delays based on difficulty level.\n   *\n   * @param deltaTime - Time since last frame in seconds\n   * @param playerState - Current player state\n   * @param aiPlayerState - Current AI player state (for combat systems)\n   * @returns Updated AI decision or null if inactive/delayed\n   */\n  update(\n    deltaTime: number,\n    playerState: PlayerState,\n    aiPlayerState: PlayerState,\n  ): AIDecision | null {\n    if (!this.state.isActive) {\n      return null;\n    }\n\n    const now = Date.now();\n\n    // Update action delay timer\n    this.actionDelayTimer = Math.max(\n      0,\n      this.actionDelayTimer - deltaTime * 1000,\n    );\n\n    // Check if enough time has passed since last decision (reaction time)\n    if (this.actionDelayTimer > 0) {\n      return this.state.currentAction;\n    }\n\n    // Build combat context\n    const context: CombatContext = {\n      playerPosition: this.state.position,\n      opponentPosition: playerState.position,\n      playerHealth: aiPlayerState.health,\n      playerMaxHealth: aiPlayerState.maxHealth,\n      playerKi: aiPlayerState.ki,\n      playerMaxKi: aiPlayerState.maxKi,\n      playerStamina: aiPlayerState.stamina,\n      playerMaxStamina: aiPlayerState.maxStamina,\n      opponentHealth: playerState.health,\n      opponentStance: playerState.currentStance,\n      playerStance: this.state.stance,\n      distanceToOpponent: this.calculateDistance(\n        this.state.position,\n        playerState.position,\n      ),\n      timeInMatch: (now - this.state.lastActionTime) / 1000,\n      isOpponentAttacking: this.isPlayerAttacking(playerState),\n      recentDamageTaken: aiPlayerState.totalDamageReceived,\n      arenaBounds: {\n        x: -8,\n        y: -6,\n        width: 16,\n        height: 12,\n        worldWidthMeters: 10, // Training area is 10m wide\n        worldDepthMeters: 7.5, // Training area is 7.5m deep (4:3 ratio)\n      },\n    };\n\n    // Get adjusted personality from adaptive difficulty\n    const adjustedPersonality = this.adjustPersonalityForTraining(\n      this.state.personality,\n    );\n\n    // Make decision using decision tree\n    const decision = this.decisionTree.makeDecision(\n      context,\n      adjustedPersonality,\n      this.comboSystem,\n    );\n\n    // Apply reaction time delay for next action\n    this.actionDelayTimer = this.state.reactionTime;\n\n    // Update state with new decision\n    this.state = {\n      ...this.state,\n      currentAction: decision,\n      lastActionTime: now,\n    };\n\n    return decision;\n  }\n\n  /**\n   * Adjust personality based on training context\n   */\n  private adjustPersonalityForTraining(\n    basePersonality: AIPersonality,\n  ): AIPersonality {\n    const config = DIFFICULTY_CONFIGS[this.state.difficulty];\n\n    // Apply difficulty multiplier to aggression\n    return {\n      ...basePersonality,\n      aggressionLevel:\n        basePersonality.aggressionLevel * config.aggressionMultiplier,\n      defensePreference:\n        basePersonality.defensePreference * (2 - config.aggressionMultiplier),\n    };\n  }\n\n  /**\n   * Calculate distance between two positions\n   */\n  private calculateDistance(pos1: Position, pos2: Position): number {\n    const dx = pos2.x - pos1.x;\n    const dy = pos2.y - pos1.y;\n    return Math.sqrt(dx * dx + dy * dy);\n  }\n\n  /**\n   * Determine if player is currently attacking\n   */\n  private isPlayerAttacking(playerState: PlayerState): boolean {\n    const timeSinceLastAction = Date.now() - playerState.lastActionTime;\n    return timeSinceLastAction < 500; // 500ms attack window\n  }\n\n  /**\n   * Update AI position (for movement actions)\n   */\n  updatePosition(newPosition: Position): void {\n    this.state = {\n      ...this.state,\n      position: newPosition,\n    };\n  }\n\n  /**\n   * Update AI stance\n   */\n  updateStance(newStance: TrigramStance): void {\n    this.state = {\n      ...this.state,\n      stance: newStance,\n    };\n  }\n\n  /**\n   * Set difficulty\n   */\n  setDifficulty(difficulty: AITrainingDifficulty): void {\n    const config = DIFFICULTY_CONFIGS[difficulty];\n    const personality = this.selectPersonalityForDifficulty(difficulty);\n\n    this.state = {\n      ...this.state,\n      difficulty,\n      personality,\n      reactionTime: config.reactionTime,\n      blockChance: config.blockChance,\n      counterChance: config.counterChance,\n    };\n\n    this.decisionTree.setDifficultyLevel(config.aiSkillLevel);\n  }\n\n  /**\n   * Reset AI state\n   */\n  reset(): void {\n    this.decisionTree.reset();\n    this.comboSystem.resetCombo();\n    this.actionDelayTimer = 0;\n\n    this.state = {\n      ...this.state,\n      currentAction: null,\n      lastActionTime: Date.now(),\n    };\n  }\n\n  /**\n   * Get current AI state (for display/debugging)\n   */\n  getState(): Readonly<TrainingAIState> {\n    return this.state;\n  }\n\n  /**\n   * Check if AI should block incoming attack\n   */\n  shouldBlock(): boolean {\n    return Math.random() < this.state.blockChance;\n  }\n\n  /**\n   * Check if AI should counter incoming attack\n   */\n  shouldCounter(): boolean {\n    return Math.random() < this.state.counterChance;\n  }\n\n  /**\n   * Get AI's current decision for debugging\n   */\n  getCurrentDecision(): AIDecision | null {\n    return this.state.currentAction;\n  }\n\n  /**\n   * Update adaptive difficulty based on match performance\n   */\n  updateAdaptiveDifficulty(matchData: {\n    readonly hitsLanded: number;\n    readonly totalAttacks: number;\n    readonly combosExecuted: number;\n    readonly perfectBlockCount: number;\n    readonly avgReactionTimeMs: number;\n    readonly vitalPointsHit: number;\n    readonly effectiveStanceChanges: number;\n    readonly damageDealt: number;\n    readonly damageTaken: number;\n  }): void {\n    this.adaptiveDifficulty.updateSkillMetrics(matchData);\n\n    // Optionally adjust difficulty based on adaptive system\n    // For training, we might want to keep difficulty stable\n  }\n}\n\nexport default TrainingAI;\n"],"mappings":"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"}

package/lib/systems/ai/__tests__/AI-Performance.bench.d.ts

@@ -0,0 +1,19 @@
+/**
+ * AI Performance Benchmarks
+ *
+ * Performance testing for AI combat decision-making to ensure real-time performance requirements:
+ * - AI decision time: <10ms average, <25ms maximum
+ * - Combat frame rate: ≥58fps average with AI active
+ * - Memory usage: No leaks over extended gameplay
+ *
+ * Benchmarks validate:
+ * - Single AI decision latency
+ * - Batch decision performance (60fps simulation)
+ * - Distance calculation hot path
+ * - Decision tree evaluation overhead
+ * - Memory allocation patterns
+ *
+ * @module systems/ai/__tests__/AI-Performance
+ */
+export {};
+//# sourceMappingURL=AI-Performance.bench.d.ts.map

package/lib/systems/ai/__tests__/AI-Performance.bench.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AI-Performance.bench.d.ts","sourceRoot":"","sources":["../../../../src/systems/ai/__tests__/AI-Performance.bench.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG"}

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

@@ -0,0 +1,12 @@
+/**
+ * @module systems/ai
+ * @category AI Systems
+ * AI combat systems for Korean martial arts
+ */
+export * from "./AIPersonality";
+export * from "./ComboSystem";
+export * from "./AdaptiveDifficulty";
+export * from "./DecisionTree";
+export * from "./TrainingAI";
+export * from "./ArchetypeEnforcer";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/systems/ai/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,cAAc,iBAAiB,CAAC;AAChC,cAAc,eAAe,CAAC;AAC9B,cAAc,sBAAsB,CAAC;AACrC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,cAAc,CAAC;AAC7B,cAAc,qBAAqB,CAAC"}

package/lib/systems/ai/index.js

@@ -0,0 +1,7 @@
+import "./AIPersonality.js";
+import "./ComboSystem.js";
+import "./AdaptiveDifficulty.js";
+import "./types.js";
+import "./ArchetypeEnforcer.js";
+import "./DecisionTree.js";
+import "./TrainingAI.js";

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

@@ -0,0 +1,111 @@
+/**
+ * AI Combat System Type Definitions
+ *
+ * Core types for AI decision-making and combat behavior.
+ * Separated to avoid circular dependencies between modules.
+ *
+ * @module systems/ai/types
+ * @category AI Combat
+ * @korean AI 전투 시스템 타입 정의
+ */
+import { Position, TrigramStance } from "../../types";
+import { BalanceState } from "../../types/player-visual";
+import type { CounterOpportunity } from "../../types/physics";
+/**
+ * AI action types
+ *
+ * @korean AI 행동 유형
+ */
+export declare enum AIActionType {
+    ATTACK = "attack",
+    TECHNIQUE = "technique",
+    DEFEND = "defend",
+    COUNTER = "counter",
+    RETREAT = "retreat",
+    APPROACH = "approach",
+    CIRCLE = "circle",
+    STANCE_CHANGE = "stance_change",
+    FEINT = "feint",
+    WAIT = "wait",
+    COMBO = "combo"
+}
+/**
+ * AI decision result
+ *
+ * @korean AI 결정 결과
+ */
+export interface AIDecision {
+    readonly action: AIActionType;
+    readonly targetPosition?: Position;
+    readonly targetStance?: TrigramStance;
+    readonly targetVitalPoint?: string;
+    readonly priority: number;
+    readonly reason: string;
+}
+/**
+ * Vulnerability assessment context for exploitation tactics
+ *
+ * Comprehensive analysis of opponent's defenseless states:
+ * - **isHelpless**: Balance === HELPLESS (90% takedown priority)
+ * - **isVulnerable**: Balance === VULNERABLE or HELPLESS (70% aggressive attack priority)
+ * - **isShaken**: Balance === SHAKEN, VULNERABLE, or HELPLESS (50% pressure tactics priority)
+ * - **hasLowStamina**: Stamina < 20% (60% exploitation priority)
+ * - **hasNoKi**: Ki < 10% (50% technique spam priority)
+ * - **overallVulnerability**: Composite vulnerability score (0.0-1.0)
+ *
+ * @korean 취약성 평가 컨텍스트
+ */
+export interface VulnerabilityContext {
+    readonly isHelpless: boolean;
+    readonly isVulnerable: boolean;
+    readonly isShaken: boolean;
+    readonly hasLowStamina: boolean;
+    readonly hasNoKi: boolean;
+    readonly overallVulnerability: number;
+}
+/**
+ * Combat context for decision making
+ *
+ * @korean 전투 컨텍스트
+ */
+export interface CombatContext {
+    readonly playerPosition: Position;
+    readonly opponentPosition: Position;
+    readonly playerHealth: number;
+    readonly playerMaxHealth: number;
+    readonly playerKi: number;
+    readonly playerMaxKi: number;
+    readonly playerStamina: number;
+    readonly playerMaxStamina: number;
+    readonly opponentHealth: number;
+    readonly opponentMaxHealth?: number;
+    readonly opponentStance: TrigramStance;
+    readonly playerStance: TrigramStance;
+    readonly distanceToOpponent: number;
+    readonly timeInMatch: number;
+    readonly isOpponentAttacking: boolean;
+    readonly recentDamageTaken: number;
+    readonly opponentBalance?: BalanceState;
+    readonly opponentStamina?: number;
+    readonly opponentMaxStamina?: number;
+    readonly opponentKi?: number;
+    readonly opponentMaxKi?: number;
+    readonly stanceFatigue?: {
+        readonly timeInStance: number;
+    };
+    readonly arenaBounds: {
+        readonly x: number;
+        readonly y: number;
+        readonly width: number;
+        readonly height: number;
+        readonly worldWidthMeters: number;
+        readonly worldDepthMeters: number;
+    };
+    /**
+     * Detected counter-attack opportunity from opponent's limb exposure.
+     * Includes exposed limb, timing window, vulnerability multiplier, and recommended counters.
+     * **Korean**: 반격 기회 (Counter Opportunity)
+     */
+    readonly counterOpportunity?: CounterOpportunity;
+}
+//# sourceMappingURL=types.d.ts.map

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

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

package/lib/systems/ai/types.js

@@ -0,0 +1,24 @@
+//#region src/systems/ai/types.ts
+/**
+* AI action types
+*
+* @korean AI 행동 유형
+*/
+var AIActionType = /* @__PURE__ */ function(AIActionType) {
+	AIActionType["ATTACK"] = "attack";
+	AIActionType["TECHNIQUE"] = "technique";
+	AIActionType["DEFEND"] = "defend";
+	AIActionType["COUNTER"] = "counter";
+	AIActionType["RETREAT"] = "retreat";
+	AIActionType["APPROACH"] = "approach";
+	AIActionType["CIRCLE"] = "circle";
+	AIActionType["STANCE_CHANGE"] = "stance_change";
+	AIActionType["FEINT"] = "feint";
+	AIActionType["WAIT"] = "wait";
+	AIActionType["COMBO"] = "combo";
+	return AIActionType;
+}({});
+//#endregion
+export { AIActionType };
+
+//# sourceMappingURL=types.js.map

package/lib/systems/ai/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","names":[],"sources":["../../../src/systems/ai/types.ts"],"sourcesContent":["/**\n * AI Combat System Type Definitions\n *\n * Core types for AI decision-making and combat behavior.\n * Separated to avoid circular dependencies between modules.\n *\n * @module systems/ai/types\n * @category AI Combat\n * @korean AI 전투 시스템 타입 정의\n */\n\nimport { Position, TrigramStance } from \"@/types\";\nimport { BalanceState } from \"@/types/player-visual\";\nimport type { CounterOpportunity } from \"@/types/physics\";\n\n/**\n * AI action types\n *\n * @korean AI 행동 유형\n */\nexport enum AIActionType {\n  ATTACK = \"attack\",\n  TECHNIQUE = \"technique\",\n  DEFEND = \"defend\",\n  COUNTER = \"counter\",\n  RETREAT = \"retreat\",\n  APPROACH = \"approach\",\n  CIRCLE = \"circle\",\n  STANCE_CHANGE = \"stance_change\",\n  FEINT = \"feint\",\n  WAIT = \"wait\",\n  COMBO = \"combo\",\n}\n\n/**\n * AI decision result\n *\n * @korean AI 결정 결과\n */\nexport interface AIDecision {\n  readonly action: AIActionType;\n  readonly targetPosition?: Position;\n  readonly targetStance?: TrigramStance;\n  readonly targetVitalPoint?: string; // ID of vital point to target\n  readonly priority: number; // 0-10: Decision confidence\n  readonly reason: string; // For debugging/analysis\n}\n\n/**\n * Vulnerability assessment context for exploitation tactics\n *\n * Comprehensive analysis of opponent's defenseless states:\n * - **isHelpless**: Balance === HELPLESS (90% takedown priority)\n * - **isVulnerable**: Balance === VULNERABLE or HELPLESS (70% aggressive attack priority)\n * - **isShaken**: Balance === SHAKEN, VULNERABLE, or HELPLESS (50% pressure tactics priority)\n * - **hasLowStamina**: Stamina < 20% (60% exploitation priority)\n * - **hasNoKi**: Ki < 10% (50% technique spam priority)\n * - **overallVulnerability**: Composite vulnerability score (0.0-1.0)\n *\n * @korean 취약성 평가 컨텍스트\n */\nexport interface VulnerabilityContext {\n  readonly isHelpless: boolean; // balance === HELPLESS\n  readonly isVulnerable: boolean; // balance === VULNERABLE or HELPLESS\n  readonly isShaken: boolean; // balance === SHAKEN, VULNERABLE, or HELPLESS\n  readonly hasLowStamina: boolean; // stamina < 20%\n  readonly hasNoKi: boolean; // ki < 10%\n  readonly overallVulnerability: number; // 0.0-1.0 composite score\n}\n\n/**\n * Combat context for decision making\n *\n * @korean 전투 컨텍스트\n */\nexport interface CombatContext {\n  readonly playerPosition: Position;\n  readonly opponentPosition: Position;\n  readonly playerHealth: number;\n  readonly playerMaxHealth: number;\n  readonly playerKi: number;\n  readonly playerMaxKi: number;\n  readonly playerStamina: number;\n  readonly playerMaxStamina: number;\n  readonly opponentHealth: number;\n  readonly opponentMaxHealth?: number; // Opponent max health (if undefined, assumes symmetric with playerMaxHealth)\n  readonly opponentStance: TrigramStance;\n  readonly playerStance: TrigramStance;\n  readonly distanceToOpponent: number;\n  readonly timeInMatch: number;\n  readonly isOpponentAttacking: boolean;\n  readonly recentDamageTaken: number;\n  readonly opponentBalance?: BalanceState; // Balance state: \"READY\" | \"SHAKEN\" | \"VULNERABLE\" | \"HELPLESS\"\n  readonly opponentStamina?: number; // Opponent stamina for exploitation\n  readonly opponentMaxStamina?: number; // Opponent max stamina\n  readonly opponentKi?: number; // Opponent ki for exploitation\n  readonly opponentMaxKi?: number; // Opponent max ki\n  readonly stanceFatigue?: {\n    readonly timeInStance: number; // Milliseconds in current stance\n  };\n  readonly arenaBounds: {\n    readonly x: number;\n    readonly y: number;\n    readonly width: number;\n    readonly height: number;\n    readonly worldWidthMeters: number; // Arena width in meters for physics calculations\n    readonly worldDepthMeters: number; // Arena depth in meters for physics calculations\n  };\n  /**\n   * Detected counter-attack opportunity from opponent's limb exposure.\n   * Includes exposed limb, timing window, vulnerability multiplier, and recommended counters.\n   * **Korean**: 반격 기회 (Counter Opportunity)\n   */\n  readonly counterOpportunity?: CounterOpportunity;\n}\n"],"mappings":";;;;;;AAoBA,IAAY,eAAL,yBAAA,cAAA;AACL,cAAA,YAAA;AACA,cAAA,eAAA;AACA,cAAA,YAAA;AACA,cAAA,aAAA;AACA,cAAA,aAAA;AACA,cAAA,cAAA;AACA,cAAA,YAAA;AACA,cAAA,mBAAA;AACA,cAAA,WAAA;AACA,cAAA,UAAA;AACA,cAAA,WAAA;;KACD"}

package/lib/systems/animation/AnimationCategory.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Animation Type Categories
+ * 애니메이션 타입 분류
+ *
+ * Represents CATEGORIES of animations, not unique instances.
+ * Multiple techniques can share the same AnimationType.
+ * Each technique has a unique AnimationId for 1-1 mapping.
+ *
+ * PROPER ARCHITECTURE:
+ * - AnimationType: Category (shared) - "What kind of animation?"
+ * - AnimationId: Unique ID (1-1 with TechniqueId) - "Which specific animation?"
+ *
+ * @module systems/animation/AnimationCategory
+ * @korean 애니메이션분류
+ */
+/**
+ * Animation Type Categories
+ *
+ * These represent broad categories of animations that can be
+ * shared across multiple techniques. The animation system uses
+ * these for categorization, fallbacks, and animation blending.
+ */
+export declare enum AnimationCategory {
+    /** Straight punches - jabs, crosses, straights */
+    PUNCH = "punch",
+    /** General strikes - palm, nerve, pressure point strikes */
+    STRIKE = "strike",
+    /** General kicks - consolidated category for all kick types */
+    KICK = "kick",
+    /** Jumping/flying kicks - aerial kicks */
+    JUMPING_KICK = "jumping_kick",
+    /** Elbow strikes */
+    ELBOW_STRIKE = "elbow_strike",
+    /** Knee strikes */
+    KNEE_STRIKE = "knee_strike",
+    /** Throwing techniques - hip throws, shoulder throws */
+    THROW = "throw",
+    /** Joint locks - arm bars, wrist locks, shoulder locks */
+    JOINT_LOCK = "joint_lock",
+    /** Takedowns - single/double leg, body locks */
+    TAKEDOWN = "takedown",
+    /** Sweeps - leg sweeps, ankle picks */
+    SWEEP = "sweep",
+    /** General grappling control */
+    GRAPPLE = "grapple",
+    /** Defensive techniques - blocks, parries, guards */
+    DEFENSIVE = "defensive",
+    /** Counter techniques - defensive counters */
+    COUNTER = "counter",
+    /** Footwork and repositioning */
+    FOOTWORK = "footwork",
+    /** Idle/ready stance */
+    STANCE = "stance"
+}
+/**
+ * Helper to get category from detailed animation name
+ * Returns consolidated categories matching the 15-category system
+ */
+export declare function getAnimationCategoryFromId(animationId: string): AnimationCategory;
+/**
+ * Validate that an animation ID matches its declared category
+ */
+export declare function validateAnimationCategory(animationId: string, declaredCategory: AnimationCategory): boolean;
+//# sourceMappingURL=AnimationCategory.d.ts.map

package/lib/systems/animation/AnimationCategory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AnimationCategory.d.ts","sourceRoot":"","sources":["../../../src/systems/animation/AnimationCategory.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH;;;;;;GAMG;AACH,oBAAY,iBAAiB;IAE3B,kDAAkD;IAClD,KAAK,UAAU;IAEf,4DAA4D;IAC5D,MAAM,WAAW;IAGjB,+DAA+D;IAC/D,IAAI,SAAS;IAEb,0CAA0C;IAC1C,YAAY,iBAAiB;IAG7B,oBAAoB;IACpB,YAAY,iBAAiB;IAE7B,mBAAmB;IACnB,WAAW,gBAAgB;IAG3B,wDAAwD;IACxD,KAAK,UAAU;IAEf,0DAA0D;IAC1D,UAAU,eAAe;IAEzB,gDAAgD;IAChD,QAAQ,aAAa;IAErB,uCAAuC;IACvC,KAAK,UAAU;IAEf,gCAAgC;IAChC,OAAO,YAAY;IAGnB,qDAAqD;IACrD,SAAS,cAAc;IAEvB,8CAA8C;IAC9C,OAAO,YAAY;IAGnB,iCAAiC;IACjC,QAAQ,aAAa;IAGrB,wBAAwB;IACxB,MAAM,WAAW;CAClB;AAED;;;GAGG;AACH,wBAAgB,0BAA0B,CAAC,WAAW,EAAE,MAAM,GAAG,iBAAiB,CA0CjF;AAED;;GAEG;AACH,wBAAgB,yBAAyB,CACvC,WAAW,EAAE,MAAM,EACnB,gBAAgB,EAAE,iBAAiB,GAClC,OAAO,CAGT"}