blacktrigram 0.7.2

package/lib/systems/combat/TrainingCombatSystem.js

@@ -0,0 +1,224 @@
+import { PlayerArchetype, TrigramStance } from "../../types/common.js";
+import CombatSystem from "../CombatSystem.js";
+//#region src/systems/combat/TrainingCombatSystem.ts
+/**
+* Training-specific combat system for Korean martial arts practice
+* Focuses on technique accuracy, form analysis, and educational feedback
+*/
+var TrainingCombatSystem = class extends CombatSystem {
+	trainingDummy;
+	accuracyHistory = [];
+	techniqueAttempts = 0;
+	successfulTechniques = 0;
+	constructor() {
+		super();
+		this.trainingDummy = this.createTrainingDummy();
+	}
+	/**
+	* Create a training dummy with infinite health for practice
+	*/
+	createTrainingDummy() {
+		return {
+			id: "training_dummy",
+			name: {
+				korean: "훈련 더미",
+				english: "Training Dummy"
+			},
+			archetype: PlayerArchetype.MUSA,
+			health: 1e3,
+			maxHealth: 1e3,
+			ki: 1e3,
+			maxKi: 1e3,
+			stamina: 1e3,
+			maxStamina: 1e3,
+			energy: 1e3,
+			maxEnergy: 1e3,
+			attackPower: 50,
+			defense: 100,
+			speed: 30,
+			technique: 50,
+			pain: 0,
+			consciousness: 100,
+			balance: 100,
+			momentum: 0,
+			currentStance: TrigramStance.GAN,
+			combatState: "idle",
+			position: {
+				x: 600,
+				y: 400
+			},
+			isBlocking: false,
+			isStunned: false,
+			isCountering: false,
+			lastActionTime: 0,
+			recoveryTime: 0,
+			lastStanceChangeTime: 0,
+			statusEffects: [],
+			activeEffects: [],
+			vitalPoints: [],
+			totalDamageReceived: 0,
+			totalDamageDealt: 0,
+			hitsTaken: 0,
+			hitsLanded: 0,
+			perfectStrikes: 0,
+			vitalPointHits: 0
+		};
+	}
+	/**
+	* Execute a training technique with detailed analysis
+	* Supports optional animation context for physics-based hit detection
+	*/
+	executeTrainingTechnique(player, technique, targetedVitalPointId, animationContext) {
+		this.techniqueAttempts++;
+		const baseResult = this.resolveAttack(player, this.trainingDummy, technique, targetedVitalPointId, animationContext);
+		const accuracyScore = this.calculateAccuracyScore(player, technique);
+		const techniqueScore = this.calculateTechniqueScore(player, technique);
+		const formScore = this.calculateFormScore(player, technique);
+		this.accuracyHistory.push(accuracyScore);
+		if (this.accuracyHistory.length > 10) this.accuracyHistory.shift();
+		if (baseResult.hit) this.successfulTechniques++;
+		const improvementAreas = this.generateImprovementAreas(accuracyScore, techniqueScore, formScore);
+		const nextTrainingGoals = this.generateTrainingGoals(player, technique, accuracyScore);
+		return {
+			...baseResult,
+			accuracyScore,
+			techniqueScore,
+			formScore,
+			improvementAreas,
+			nextTrainingGoals
+		};
+	}
+	/**
+	* Calculate accuracy score based on stance, timing, and targeting
+	*/
+	calculateAccuracyScore(player, _technique) {
+		let score = .5;
+		score += player.technique / 100 * .2;
+		return Math.min(1, Math.max(0, score));
+	}
+	/**
+	* Calculate technique execution score
+	*/
+	calculateTechniqueScore(player, _technique) {
+		let score = .6;
+		const kiRatio = player.ki / player.maxKi;
+		const staminaRatio = player.stamina / player.maxStamina;
+		score += kiRatio * .2;
+		score += staminaRatio * .2;
+		return Math.min(1, Math.max(0, score));
+	}
+	/**
+	* Calculate form score based on balance and positioning
+	*/
+	calculateFormScore(_player, _technique) {
+		return Math.min(1, Math.max(0, .5));
+	}
+	/**
+	* Generate areas for improvement based on scores
+	*/
+	generateImprovementAreas(accuracy, technique, form) {
+		const areas = [];
+		if (accuracy < .7) areas.push("targeting_precision");
+		if (technique < .7) areas.push("technique_execution");
+		if (form < .7) areas.push("stance_stability");
+		const koreanAreas = areas.map((area) => {
+			switch (area) {
+				case "targeting_precision": return "타겟팅 정확도 - Targeting Precision";
+				case "technique_execution": return "기법 실행 - Technique Execution";
+				case "stance_stability": return "자세 안정성 - Stance Stability";
+				default: return area;
+			}
+		});
+		return koreanAreas.length > 0 ? koreanAreas : ["전반적 향상 - Overall Improvement"];
+	}
+	/**
+	* Generate next training goals
+	*/
+	generateTrainingGoals(_player, technique, accuracy) {
+		const goals = [];
+		if (accuracy > .8) goals.push("고급 기법 연습 - Practice Advanced Techniques");
+		else if (accuracy > .6) goals.push("연속 기법 연습 - Practice Combo Techniques");
+		else goals.push("기본 자세 연습 - Practice Basic Stances");
+		const stanceGoals = this.getStanceSpecificGoals(technique.stance);
+		goals.push(...stanceGoals);
+		return goals.slice(0, 3);
+	}
+	/**
+	* Get stance-specific training goals
+	*/
+	getStanceSpecificGoals(stance) {
+		return {
+			[TrigramStance.GEON]: ["천괘 직선 공격 마스터 - Master Heaven's Direct Attacks"],
+			[TrigramStance.TAE]: ["태괘 유동성 향상 - Improve Lake's Fluidity"],
+			[TrigramStance.LI]: ["리괘 정확성 훈련 - Train Fire's Precision"],
+			[TrigramStance.JIN]: ["진괘 폭발력 개발 - Develop Thunder's Power"],
+			[TrigramStance.SON]: ["손괘 연속성 연습 - Practice Wind's Continuity"],
+			[TrigramStance.GAM]: ["감괘 적응력 향상 - Improve Water's Adaptability"],
+			[TrigramStance.GAN]: ["간괘 방어력 강화 - Strengthen Mountain's Defense"],
+			[TrigramStance.GON]: ["곤괘 제압력 훈련 - Train Earth's Control"]
+		}[stance] || ["기본 자세 완성 - Perfect Basic Stance"];
+	}
+	/**
+	* Get training statistics
+	*/
+	getTrainingStats() {
+		const overallAccuracy = this.accuracyHistory.length > 0 ? this.accuracyHistory.reduce((a, b) => a + b, 0) / this.accuracyHistory.length : 0;
+		const successRate = this.techniqueAttempts > 0 ? this.successfulTechniques / this.techniqueAttempts : 0;
+		return {
+			totalAttempts: this.techniqueAttempts,
+			successfulTechniques: this.successfulTechniques,
+			successRate,
+			overallAccuracy,
+			recentAccuracy: this.accuracyHistory.slice(-5),
+			improvementTrend: this.calculateImprovementTrend()
+		};
+	}
+	/**
+	* Calculate improvement trend from recent accuracy scores
+	*/
+	calculateImprovementTrend() {
+		if (this.accuracyHistory.length < 5) return "stable";
+		const recent = this.accuracyHistory.slice(-3);
+		const earlier = this.accuracyHistory.slice(-6, -3);
+		if (earlier.length === 0) return "stable";
+		const diff = recent.reduce((a, b) => a + b, 0) / recent.length - earlier.reduce((a, b) => a + b, 0) / earlier.length;
+		if (diff > .1) return "improving";
+		if (diff < -.1) return "declining";
+		return "stable";
+	}
+	/**
+	* Reset training session
+	*/
+	resetTrainingSession() {
+		this.accuracyHistory = [];
+		this.techniqueAttempts = 0;
+		this.successfulTechniques = 0;
+		this.trainingDummy = this.createTrainingDummy();
+	}
+	/**
+	* Fix: Add the missing resetTrainingDummy method that tests expect
+	*/
+	resetTrainingDummy() {
+		this.trainingDummy = this.createTrainingDummy();
+	}
+	/**
+	* Get training dummy for display
+	*/
+	getTrainingDummy() {
+		return this.trainingDummy;
+	}
+	/**
+	* Update training dummy health (for visual feedback)
+	*/
+	updateTrainingDummy(updates) {
+		this.trainingDummy = {
+			...this.trainingDummy,
+			...updates,
+			health: Math.max(this.trainingDummy.health, 900)
+		};
+	}
+};
+//#endregion
+export { TrainingCombatSystem as default };
+
+//# sourceMappingURL=TrainingCombatSystem.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"TrainingCombatSystem.js","names":[],"sources":["../../../src/systems/combat/TrainingCombatSystem.ts"],"sourcesContent":["import { PlayerArchetype, TrigramStance } from \"../../types/common\";\nimport { AnimationType } from \"../animation\";\nimport { CombatSystem } from \"../CombatSystem\";\nimport { PlayerState } from \"../player\";\nimport { KoreanTechnique } from \"../vitalpoint\";\nimport { TrainingCombatResult } from \"./types\";\n\n/**\n * Animation context for timing-based hit detection\n */\ninterface AnimationContext {\n  readonly animationType: AnimationType;\n  readonly currentTime: number;\n}\n\n/**\n * Training-specific combat system for Korean martial arts practice\n * Focuses on technique accuracy, form analysis, and educational feedback\n */\nexport class TrainingCombatSystem extends CombatSystem {\n  private trainingDummy: PlayerState;\n  private accuracyHistory: number[] = [];\n  private techniqueAttempts: number = 0;\n  private successfulTechniques: number = 0;\n\n  constructor() {\n    super();\n    this.trainingDummy = this.createTrainingDummy();\n  }\n\n  /**\n   * Create a training dummy with infinite health for practice\n   */\n  private createTrainingDummy(): PlayerState {\n    return {\n      id: \"training_dummy\",\n      name: { korean: \"훈련 더미\", english: \"Training Dummy\" },\n      archetype: PlayerArchetype.MUSA,\n      health: 1000,\n      maxHealth: 1000,\n      ki: 1000,\n      maxKi: 1000,\n      stamina: 1000,\n      maxStamina: 1000,\n      energy: 1000,\n      maxEnergy: 1000,\n      attackPower: 50,\n      defense: 100,\n      speed: 30,\n      technique: 50,\n      pain: 0,\n      consciousness: 100,\n      balance: 100,\n      momentum: 0,\n      currentStance: TrigramStance.GAN, // Mountain stance - defensive\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any -- CombatState type is narrower than string literal\n      combatState: \"idle\" as any,\n      position: { x: 600, y: 400 },\n      isBlocking: false,\n      isStunned: false,\n      isCountering: false,\n      lastActionTime: 0,\n      recoveryTime: 0,\n      lastStanceChangeTime: 0,\n      statusEffects: [],\n      activeEffects: [],\n      vitalPoints: [],\n      totalDamageReceived: 0,\n      totalDamageDealt: 0,\n      hitsTaken: 0,\n      hitsLanded: 0,\n      perfectStrikes: 0,\n      vitalPointHits: 0,\n    };\n  }\n\n  /**\n   * Execute a training technique with detailed analysis\n   * Supports optional animation context for physics-based hit detection\n   */\n  executeTrainingTechnique(\n    player: PlayerState,\n    technique: KoreanTechnique,\n    targetedVitalPointId?: string,\n    animationContext?: AnimationContext,\n  ): TrainingCombatResult {\n    this.techniqueAttempts++;\n\n    // Base combat resolution with animation context\n    const baseResult = this.resolveAttack(\n      player,\n      this.trainingDummy,\n      technique,\n      targetedVitalPointId,\n      animationContext,\n    );\n\n    // Calculate training-specific scores\n    const accuracyScore = this.calculateAccuracyScore(player, technique);\n    const techniqueScore = this.calculateTechniqueScore(player, technique);\n    const formScore = this.calculateFormScore(player, technique);\n\n    this.accuracyHistory.push(accuracyScore);\n    if (this.accuracyHistory.length > 10) {\n      this.accuracyHistory.shift(); // Keep last 10 attempts\n    }\n\n    if (baseResult.hit) {\n      this.successfulTechniques++;\n    }\n\n    // Generate improvement feedback\n    const improvementAreas = this.generateImprovementAreas(\n      accuracyScore,\n      techniqueScore,\n      formScore,\n    );\n\n    const nextTrainingGoals = this.generateTrainingGoals(\n      player,\n      technique,\n      accuracyScore,\n    );\n\n    return {\n      ...baseResult,\n      accuracyScore,\n      techniqueScore,\n      formScore,\n      improvementAreas,\n      nextTrainingGoals,\n    };\n  }\n\n  /**\n   * Calculate accuracy score based on stance, timing, and targeting\n   */\n  private calculateAccuracyScore(\n    player: PlayerState,\n    _technique: KoreanTechnique,\n  ): number {\n    let score = 0.5; // Base score\n\n    // Player technique skill\n    score += (player.technique / 100) * 0.2;\n\n    return Math.min(1.0, Math.max(0.0, score));\n  }\n\n  /**\n   * Calculate technique execution score\n   */\n  private calculateTechniqueScore(\n    player: PlayerState,\n    _technique: KoreanTechnique,\n  ): number {\n    let score = 0.6; // Base execution\n\n    // Ki and stamina availability\n    const kiRatio = player.ki / player.maxKi;\n    const staminaRatio = player.stamina / player.maxStamina;\n\n    score += kiRatio * 0.2;\n    score += staminaRatio * 0.2;\n\n    return Math.min(1.0, Math.max(0.0, score));\n  }\n\n  /**\n   * Calculate form score based on balance and positioning\n   */\n  private calculateFormScore(\n    _player: PlayerState,\n    _technique: KoreanTechnique,\n  ): number {\n    const score = 0.5; // Base form\n\n    // For now, return base form score\n    return Math.min(1.0, Math.max(0.0, score));\n  }\n\n  /**\n   * Generate areas for improvement based on scores\n   */\n  private generateImprovementAreas(\n    accuracy: number,\n    technique: number,\n    form: number,\n  ): string[] {\n    const areas: string[] = [];\n\n    if (accuracy < 0.7) {\n      areas.push(\"targeting_precision\");\n    }\n    if (technique < 0.7) {\n      areas.push(\"technique_execution\");\n    }\n    if (form < 0.7) {\n      areas.push(\"stance_stability\");\n    }\n\n    // Korean translations\n    const koreanAreas = areas.map((area) => {\n      switch (area) {\n        case \"targeting_precision\":\n          return \"타겟팅 정확도 - Targeting Precision\";\n        case \"technique_execution\":\n          return \"기법 실행 - Technique Execution\";\n        case \"stance_stability\":\n          return \"자세 안정성 - Stance Stability\";\n        default:\n          return area;\n      }\n    });\n\n    return koreanAreas.length > 0\n      ? koreanAreas\n      : [\"전반적 향상 - Overall Improvement\"];\n  }\n\n  /**\n   * Generate next training goals\n   */\n  private generateTrainingGoals(\n    // Fix: Remove unused player parameter\n    _player: PlayerState,\n    technique: KoreanTechnique,\n    accuracy: number,\n  ): string[] {\n    const goals: string[] = [];\n\n    if (accuracy > 0.8) {\n      goals.push(\"고급 기법 연습 - Practice Advanced Techniques\");\n    } else if (accuracy > 0.6) {\n      goals.push(\"연속 기법 연습 - Practice Combo Techniques\");\n    } else {\n      goals.push(\"기본 자세 연습 - Practice Basic Stances\");\n    }\n\n    // Add stance-specific goals\n    const stanceGoals = this.getStanceSpecificGoals(technique.stance);\n    goals.push(...stanceGoals);\n\n    return goals.slice(0, 3); // Limit to 3 goals\n  }\n\n  /**\n   * Get stance-specific training goals\n   */\n  private getStanceSpecificGoals(stance: TrigramStance): string[] {\n    const stanceGoals: Record<TrigramStance, string[]> = {\n      [TrigramStance.GEON]: [\n        \"천괘 직선 공격 마스터 - Master Heaven's Direct Attacks\",\n      ],\n      [TrigramStance.TAE]: [\"태괘 유동성 향상 - Improve Lake's Fluidity\"],\n      [TrigramStance.LI]: [\"리괘 정확성 훈련 - Train Fire's Precision\"],\n      [TrigramStance.JIN]: [\"진괘 폭발력 개발 - Develop Thunder's Power\"],\n      [TrigramStance.SON]: [\"손괘 연속성 연습 - Practice Wind's Continuity\"],\n      [TrigramStance.GAM]: [\"감괘 적응력 향상 - Improve Water's Adaptability\"],\n      [TrigramStance.GAN]: [\"간괘 방어력 강화 - Strengthen Mountain's Defense\"],\n      [TrigramStance.GON]: [\"곤괘 제압력 훈련 - Train Earth's Control\"],\n    };\n\n    return stanceGoals[stance] || [\"기본 자세 완성 - Perfect Basic Stance\"];\n  }\n\n  /**\n   * Get training statistics\n   */\n  getTrainingStats() {\n    const overallAccuracy =\n      this.accuracyHistory.length > 0\n        ? this.accuracyHistory.reduce((a, b) => a + b, 0) /\n          this.accuracyHistory.length\n        : 0;\n\n    const successRate =\n      this.techniqueAttempts > 0\n        ? this.successfulTechniques / this.techniqueAttempts\n        : 0;\n\n    return {\n      totalAttempts: this.techniqueAttempts,\n      successfulTechniques: this.successfulTechniques,\n      successRate,\n      overallAccuracy,\n      recentAccuracy: this.accuracyHistory.slice(-5),\n      improvementTrend: this.calculateImprovementTrend(),\n    };\n  }\n\n  /**\n   * Calculate improvement trend from recent accuracy scores\n   */\n  private calculateImprovementTrend(): \"improving\" | \"stable\" | \"declining\" {\n    if (this.accuracyHistory.length < 5) return \"stable\";\n\n    const recent = this.accuracyHistory.slice(-3);\n    const earlier = this.accuracyHistory.slice(-6, -3);\n\n    if (earlier.length === 0) return \"stable\";\n\n    const recentAvg = recent.reduce((a, b) => a + b, 0) / recent.length;\n    const earlierAvg = earlier.reduce((a, b) => a + b, 0) / earlier.length;\n\n    const diff = recentAvg - earlierAvg;\n\n    if (diff > 0.1) return \"improving\";\n    if (diff < -0.1) return \"declining\";\n    return \"stable\";\n  }\n\n  /**\n   * Reset training session\n   */\n  resetTrainingSession() {\n    this.accuracyHistory = [];\n    this.techniqueAttempts = 0;\n    this.successfulTechniques = 0;\n    this.trainingDummy = this.createTrainingDummy();\n  }\n\n  /**\n   * Fix: Add the missing resetTrainingDummy method that tests expect\n   */\n  resetTrainingDummy() {\n    this.trainingDummy = this.createTrainingDummy();\n  }\n\n  /**\n   * Get training dummy for display\n   */\n  getTrainingDummy(): PlayerState {\n    return this.trainingDummy;\n  }\n\n  /**\n   * Update training dummy health (for visual feedback)\n   */\n  updateTrainingDummy(updates: Partial<PlayerState>) {\n    this.trainingDummy = {\n      ...this.trainingDummy,\n      ...updates,\n      // Always keep high health for training\n      health: Math.max(this.trainingDummy.health, 900),\n    };\n  }\n}\n\nexport default TrainingCombatSystem;\n"],"mappings":"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"}

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

@@ -0,0 +1,16 @@
+/**
+ * @module systems/combat
+ * @category Combat System
+ */
+export * from "./TrainingCombatSystem";
+export * from "./types";
+export * from "./typeGuards";
+export * from "./CombatStateSystem";
+export * from "./ConsciousnessSystem";
+export * from "./PainResponseSystem";
+export * from "./BalanceSystem";
+export * from "./painConsciousnessUtils";
+export * from "./GrappleSystem";
+export * from "./LimbExposureSystem";
+export * from "./BreakingStatusEffects";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/systems/combat/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,cAAc,wBAAwB,CAAC;AACvC,cAAc,SAAS,CAAC;AACxB,cAAc,cAAc,CAAC;AAC7B,cAAc,qBAAqB,CAAC;AACpC,cAAc,uBAAuB,CAAC;AACtC,cAAc,sBAAsB,CAAC;AACrC,cAAc,iBAAiB,CAAC;AAChC,cAAc,0BAA0B,CAAC;AACzC,cAAc,iBAAiB,CAAC;AAChC,cAAc,sBAAsB,CAAC;AACrC,cAAc,yBAAyB,CAAC"}

package/lib/systems/combat/index.js

@@ -0,0 +1,10 @@
+import "./BalanceSystem.js";
+import "./ConsciousnessSystem.js";
+import "./painConsciousnessUtils.js";
+import "./PainResponseSystem.js";
+import "./GrappleSystem.js";
+import "./TrainingCombatSystem.js";
+import "./typeGuards.js";
+import "./CombatStateSystem.js";
+import "./BreakingStatusEffects.js";
+import "./LimbExposureSystem.js";

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

@@ -0,0 +1,147 @@
+/**
+ * Utility functions for Pain and Consciousness management in combat.
+ *
+ * **Korean**: 고통 의식 관리 유틸리티
+ *
+ * Provides helper functions for managing pain and consciousness effects
+ * in combat scenarios, including status checking, effect application,
+ * and recovery management.
+ *
+ * @module systems/combat/painConsciousnessUtils
+ * @category Combat System
+ */
+import { PlayerState } from "../player";
+import { VitalPointCategory } from "../../types";
+import { CombatResult } from "./types";
+import PainResponseSystem, { PainLevel, ShockPainEffect } from "./PainResponseSystem";
+import ConsciousnessSystem, { ConsciousnessLevel } from "./ConsciousnessSystem";
+/**
+ * Pain and consciousness status information.
+ */
+export interface PainConsciousnessStatus {
+    /** Current pain level */
+    readonly painLevel: PainLevel;
+    /** Current consciousness level */
+    readonly consciousnessLevel: ConsciousnessLevel;
+    /** Whether player is in pain overload */
+    readonly isInPainOverload: boolean;
+    /** Whether player is at incapacitation threshold */
+    readonly isIncapacitated: boolean;
+    /** Whether player is combat effective */
+    readonly isCombatEffective: boolean;
+    /** Overall combat effectiveness percentage (0-1) */
+    readonly combatEffectiveness: number;
+    /** Bilingual status description */
+    readonly statusDescription: {
+        readonly korean: string;
+        readonly english: string;
+    };
+}
+/**
+ * Gets comprehensive pain and consciousness status for a player.
+ *
+ * @param player - Player to check status for
+ * @param painSystem - Pain response system instance
+ * @param consciousnessSystem - Consciousness system instance
+ * @returns Comprehensive status information
+ *
+ * @example
+ * ```typescript
+ * const status = getPainConsciousnessStatus(player, painSystem, consciousnessSystem);
+ * console.log(`Combat effectiveness: ${status.combatEffectiveness * 100}%`);
+ * console.log(`Status: ${status.statusDescription.english}`);
+ * ```
+ *
+ * @public
+ * @korean 상태확인
+ */
+export declare function getPainConsciousnessStatus(player: PlayerState, painSystem: PainResponseSystem, consciousnessSystem: ConsciousnessSystem): PainConsciousnessStatus;
+/**
+ * Determines if a combat result should trigger head trauma.
+ *
+ * Head trauma occurs for:
+ * - Neurological vital point hits
+ * - Vascular hits to head region
+ * - High damage hits (>25) that could cause concussion
+ * - Critical hits to upper body
+ *
+ * @param result - Combat result to check
+ * @param category - Vital point category if known
+ * @returns True if result should cause head trauma
+ *
+ * @public
+ * @korean 두부외상확인
+ */
+export declare function isHeadTraumaHit(result: CombatResult, category?: VitalPointCategory): boolean;
+/**
+ * Extracts vital point category from combat result.
+ *
+ * Uses heuristics to determine category from effect sources and hit data.
+ *
+ * @param result - Combat result
+ * @returns Vital point category if determinable
+ *
+ * @public
+ * @korean 급소분류추출
+ */
+export declare function extractVitalPointCategory(result: CombatResult): VitalPointCategory | undefined;
+/**
+ * Calculates recommended recovery time based on player condition.
+ *
+ * @param player - Player state
+ * @param consciousnessSystem - Consciousness system
+ * @returns Estimated recovery time in seconds
+ *
+ * @example
+ * ```typescript
+ * const recoveryTime = getRecommendedRecoveryTime(player, consciousnessSystem);
+ * console.log(`Recovery needed: ${recoveryTime}s`);
+ * ```
+ *
+ * @public
+ * @korean 회복시간계산
+ */
+export declare function getRecommendedRecoveryTime(player: PlayerState, consciousnessSystem: ConsciousnessSystem): number;
+/**
+ * Checks if shock pain effect is still active.
+ *
+ * @param shockEffect - Shock pain effect to check
+ * @returns True if effect is still active
+ *
+ * @public
+ * @korean 충격통활성확인
+ */
+export declare function isShockPainActive(shockEffect: ShockPainEffect): boolean;
+/**
+ * Gets remaining shock pain duration.
+ *
+ * @param shockEffect - Shock pain effect
+ * @returns Remaining duration in milliseconds, or 0 if expired
+ *
+ * @public
+ * @korean 충격통잔여시간
+ */
+export declare function getShockPainRemainingDuration(shockEffect: ShockPainEffect): number;
+/**
+ * Formats pain and consciousness values for display.
+ *
+ * @param player - Player state
+ * @returns Formatted display strings
+ *
+ * @example
+ * ```typescript
+ * const display = formatPainConsciousnessDisplay(player);
+ * console.log(display.pain); // "Pain: 45/100"
+ * console.log(display.consciousness); // "Consciousness: 85/100"
+ * ```
+ *
+ * @public
+ * @korean 표시형식
+ */
+export declare function formatPainConsciousnessDisplay(player: PlayerState): {
+    readonly pain: string;
+    readonly consciousness: string;
+    readonly painKorean: string;
+    readonly consciousnessKorean: string;
+};
+//# sourceMappingURL=painConsciousnessUtils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"painConsciousnessUtils.d.ts","sourceRoot":"","sources":["../../../src/systems/combat/painConsciousnessUtils.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AACxC,OAAO,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAC7C,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AACvC,OAAO,kBAAkB,EAAE,EAAE,SAAS,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AACtF,OAAO,mBAAmB,EAAE,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAEhF;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACtC,yBAAyB;IACzB,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAC;IAC9B,kCAAkC;IAClC,QAAQ,CAAC,kBAAkB,EAAE,kBAAkB,CAAC;IAChD,yCAAyC;IACzC,QAAQ,CAAC,gBAAgB,EAAE,OAAO,CAAC;IACnC,oDAAoD;IACpD,QAAQ,CAAC,eAAe,EAAE,OAAO,CAAC;IAClC,yCAAyC;IACzC,QAAQ,CAAC,iBAAiB,EAAE,OAAO,CAAC;IACpC,oDAAoD;IACpD,QAAQ,CAAC,mBAAmB,EAAE,MAAM,CAAC;IACrC,mCAAmC;IACnC,QAAQ,CAAC,iBAAiB,EAAE;QAC1B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;QACxB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;KAC1B,CAAC;CACH;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,WAAW,EACnB,UAAU,EAAE,kBAAkB,EAC9B,mBAAmB,EAAE,mBAAmB,GACvC,uBAAuB,CAyCzB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,eAAe,CAC7B,MAAM,EAAE,YAAY,EACpB,QAAQ,CAAC,EAAE,kBAAkB,GAC5B,OAAO,CAsBT;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,YAAY,GAAG,kBAAkB,GAAG,SAAS,CAoC9F;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,WAAW,EACnB,mBAAmB,EAAE,mBAAmB,GACvC,MAAM,CA4BR;AAED;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,eAAe,GAAG,OAAO,CAGvE;AAED;;;;;;;;GAQG;AACH,wBAAgB,6BAA6B,CAAC,WAAW,EAAE,eAAe,GAAG,MAAM,CAGlF;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,8BAA8B,CAAC,MAAM,EAAE,WAAW,GAAG;IACnE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,mBAAmB,EAAE,MAAM,CAAC;CACtC,CAOA"}

package/lib/systems/combat/painConsciousnessUtils.js

@@ -0,0 +1,185 @@
+import { VitalPointCategory } from "../../types/common.js";
+import "../../types/index.js";
+import { ConsciousnessLevel } from "./ConsciousnessSystem.js";
+//#region src/systems/combat/painConsciousnessUtils.ts
+/**
+* Gets comprehensive pain and consciousness status for a player.
+* 
+* @param player - Player to check status for
+* @param painSystem - Pain response system instance
+* @param consciousnessSystem - Consciousness system instance
+* @returns Comprehensive status information
+* 
+* @example
+* ```typescript
+* const status = getPainConsciousnessStatus(player, painSystem, consciousnessSystem);
+* console.log(`Combat effectiveness: ${status.combatEffectiveness * 100}%`);
+* console.log(`Status: ${status.statusDescription.english}`);
+* ```
+* 
+* @public
+* @korean 상태확인
+*/
+function getPainConsciousnessStatus(player, painSystem, consciousnessSystem) {
+	const painLevel = painSystem.getPainLevel(player.pain);
+	const consciousnessLevel = consciousnessSystem.getLevel(player.consciousness);
+	const isInPainOverload = painSystem.isInPainOverload(player);
+	const isIncapacitated = consciousnessSystem.isAtIncapacitationThreshold(player);
+	const painPenalty = painSystem.getEffects(painLevel).performancePenalty;
+	const consciousnessPenalty = consciousnessSystem.getEffects(consciousnessLevel).accuracyPenalty;
+	const combatEffectiveness = Math.max(0, 1 - Math.max(painPenalty, consciousnessPenalty));
+	const isCombatEffective = combatEffectiveness > .5;
+	const painName = painSystem.getLevelName(painLevel);
+	const consciousnessName = consciousnessSystem.getLevelName(consciousnessLevel);
+	let statusKorean = `고통: ${painName.korean}, 의식: ${consciousnessName.korean}`;
+	let statusEnglish = `Pain: ${painName.english}, Consciousness: ${consciousnessName.english}`;
+	if (isIncapacitated) {
+		statusKorean = "무력화 상태";
+		statusEnglish = "Incapacitated";
+	} else if (isInPainOverload) {
+		statusKorean = "고통 과부하";
+		statusEnglish = "Pain Overload";
+	}
+	return {
+		painLevel,
+		consciousnessLevel,
+		isInPainOverload,
+		isIncapacitated,
+		isCombatEffective,
+		combatEffectiveness,
+		statusDescription: {
+			korean: statusKorean,
+			english: statusEnglish
+		}
+	};
+}
+/**
+* Determines if a combat result should trigger head trauma.
+* 
+* Head trauma occurs for:
+* - Neurological vital point hits
+* - Vascular hits to head region
+* - High damage hits (>25) that could cause concussion
+* - Critical hits to upper body
+* 
+* @param result - Combat result to check
+* @param category - Vital point category if known
+* @returns True if result should cause head trauma
+* 
+* @public
+* @korean 두부외상확인
+*/
+function isHeadTraumaHit(result, category) {
+	if (category === VitalPointCategory.NEUROLOGICAL) return true;
+	if (category === VitalPointCategory.VASCULAR && result.damage > 15) return true;
+	if (result.damage > 25) return true;
+	if (result.isCritical && result.vitalPointHit) return true;
+	return false;
+}
+/**
+* Extracts vital point category from combat result.
+* 
+* Uses heuristics to determine category from effect sources and hit data.
+* 
+* @param result - Combat result
+* @returns Vital point category if determinable
+* 
+* @public
+* @korean 급소분류추출
+*/
+function extractVitalPointCategory(result) {
+	if (!result.vitalPointHit || !result.effects || result.effects.length === 0) return;
+	const effect = result.effects[0];
+	if (!effect.source) return;
+	const source = effect.source.toLowerCase();
+	if (source.includes("neuro") || source.includes("nerve")) return VitalPointCategory.NEUROLOGICAL;
+	if (source.includes("vascular") || source.includes("blood") || source.includes("artery")) return VitalPointCategory.VASCULAR;
+	if (source.includes("respiratory") || source.includes("breath") || source.includes("lung")) return VitalPointCategory.RESPIRATORY;
+	if (source.includes("skeletal") || source.includes("bone")) return VitalPointCategory.SKELETAL;
+	if (source.includes("muscular") || source.includes("muscle")) return VitalPointCategory.MUSCULAR;
+	if (source.includes("organ") || source.includes("visceral")) return VitalPointCategory.ORGAN;
+	if (source.includes("joint")) return VitalPointCategory.JOINT;
+}
+/**
+* Calculates recommended recovery time based on player condition.
+* 
+* @param player - Player state
+* @param consciousnessSystem - Consciousness system
+* @returns Estimated recovery time in seconds
+* 
+* @example
+* ```typescript
+* const recoveryTime = getRecommendedRecoveryTime(player, consciousnessSystem);
+* console.log(`Recovery needed: ${recoveryTime}s`);
+* ```
+* 
+* @public
+* @korean 회복시간계산
+*/
+function getRecommendedRecoveryTime(player, consciousnessSystem) {
+	let painRecoveryTime = 0;
+	let consciousnessRecoveryTime = 0;
+	if (player.pain > 0) painRecoveryTime = player.pain / 5;
+	if (player.consciousness < 100) {
+		const consciousnessToRecover = 100 - player.consciousness;
+		const consciousnessLevel = consciousnessSystem.getLevel(player.consciousness);
+		let recoveryRate = 5;
+		if (consciousnessLevel === ConsciousnessLevel.STUNNED) recoveryRate = 2.5;
+		else if (consciousnessLevel === ConsciousnessLevel.UNCONSCIOUS) recoveryRate = 1;
+		consciousnessRecoveryTime = 5 + consciousnessToRecover / recoveryRate;
+	}
+	return Math.ceil(Math.max(painRecoveryTime, consciousnessRecoveryTime));
+}
+/**
+* Checks if shock pain effect is still active.
+* 
+* @param shockEffect - Shock pain effect to check
+* @returns True if effect is still active
+* 
+* @public
+* @korean 충격통활성확인
+*/
+function isShockPainActive(shockEffect) {
+	return Date.now() - shockEffect.startTime < shockEffect.duration;
+}
+/**
+* Gets remaining shock pain duration.
+* 
+* @param shockEffect - Shock pain effect
+* @returns Remaining duration in milliseconds, or 0 if expired
+* 
+* @public
+* @korean 충격통잔여시간
+*/
+function getShockPainRemainingDuration(shockEffect) {
+	const elapsed = Date.now() - shockEffect.startTime;
+	return Math.max(0, shockEffect.duration - elapsed);
+}
+/**
+* Formats pain and consciousness values for display.
+* 
+* @param player - Player state
+* @returns Formatted display strings
+* 
+* @example
+* ```typescript
+* const display = formatPainConsciousnessDisplay(player);
+* console.log(display.pain); // "Pain: 45/100"
+* console.log(display.consciousness); // "Consciousness: 85/100"
+* ```
+* 
+* @public
+* @korean 표시형식
+*/
+function formatPainConsciousnessDisplay(player) {
+	return {
+		pain: `Pain: ${Math.floor(player.pain)}/100`,
+		consciousness: `Consciousness: ${Math.floor(player.consciousness)}/100`,
+		painKorean: `고통: ${Math.floor(player.pain)}/100`,
+		consciousnessKorean: `의식: ${Math.floor(player.consciousness)}/100`
+	};
+}
+//#endregion
+export { extractVitalPointCategory, formatPainConsciousnessDisplay, getPainConsciousnessStatus, getRecommendedRecoveryTime, getShockPainRemainingDuration, isHeadTraumaHit, isShockPainActive };
+
+//# sourceMappingURL=painConsciousnessUtils.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"painConsciousnessUtils.js","names":[],"sources":["../../../src/systems/combat/painConsciousnessUtils.ts"],"sourcesContent":["/**\n * Utility functions for Pain and Consciousness management in combat.\n * \n * **Korean**: 고통 의식 관리 유틸리티\n * \n * Provides helper functions for managing pain and consciousness effects\n * in combat scenarios, including status checking, effect application,\n * and recovery management.\n * \n * @module systems/combat/painConsciousnessUtils\n * @category Combat System\n */\n\nimport { PlayerState } from \"../player\";\nimport { VitalPointCategory } from \"@/types\";\nimport { CombatResult } from \"./types\";\nimport PainResponseSystem, { PainLevel, ShockPainEffect } from \"./PainResponseSystem\";\nimport ConsciousnessSystem, { ConsciousnessLevel } from \"./ConsciousnessSystem\";\n\n/**\n * Pain and consciousness status information.\n */\nexport interface PainConsciousnessStatus {\n  /** Current pain level */\n  readonly painLevel: PainLevel;\n  /** Current consciousness level */\n  readonly consciousnessLevel: ConsciousnessLevel;\n  /** Whether player is in pain overload */\n  readonly isInPainOverload: boolean;\n  /** Whether player is at incapacitation threshold */\n  readonly isIncapacitated: boolean;\n  /** Whether player is combat effective */\n  readonly isCombatEffective: boolean;\n  /** Overall combat effectiveness percentage (0-1) */\n  readonly combatEffectiveness: number;\n  /** Bilingual status description */\n  readonly statusDescription: {\n    readonly korean: string;\n    readonly english: string;\n  };\n}\n\n/**\n * Gets comprehensive pain and consciousness status for a player.\n * \n * @param player - Player to check status for\n * @param painSystem - Pain response system instance\n * @param consciousnessSystem - Consciousness system instance\n * @returns Comprehensive status information\n * \n * @example\n * ```typescript\n * const status = getPainConsciousnessStatus(player, painSystem, consciousnessSystem);\n * console.log(`Combat effectiveness: ${status.combatEffectiveness * 100}%`);\n * console.log(`Status: ${status.statusDescription.english}`);\n * ```\n * \n * @public\n * @korean 상태확인\n */\nexport function getPainConsciousnessStatus(\n  player: PlayerState,\n  painSystem: PainResponseSystem,\n  consciousnessSystem: ConsciousnessSystem\n): PainConsciousnessStatus {\n  const painLevel = painSystem.getPainLevel(player.pain);\n  const consciousnessLevel = consciousnessSystem.getLevel(player.consciousness);\n  \n  const isInPainOverload = painSystem.isInPainOverload(player);\n  const isIncapacitated = consciousnessSystem.isAtIncapacitationThreshold(player);\n  \n  // Calculate overall combat effectiveness\n  const painPenalty = painSystem.getEffects(painLevel).performancePenalty;\n  const consciousnessPenalty = consciousnessSystem.getEffects(consciousnessLevel).accuracyPenalty;\n  const combatEffectiveness = Math.max(0, 1 - Math.max(painPenalty, consciousnessPenalty));\n  \n  const isCombatEffective = combatEffectiveness > 0.5;\n  \n  // Generate status description\n  const painName = painSystem.getLevelName(painLevel);\n  const consciousnessName = consciousnessSystem.getLevelName(consciousnessLevel);\n  \n  let statusKorean = `고통: ${painName.korean}, 의식: ${consciousnessName.korean}`;\n  let statusEnglish = `Pain: ${painName.english}, Consciousness: ${consciousnessName.english}`;\n  \n  if (isIncapacitated) {\n    statusKorean = \"무력화 상태\";\n    statusEnglish = \"Incapacitated\";\n  } else if (isInPainOverload) {\n    statusKorean = \"고통 과부하\";\n    statusEnglish = \"Pain Overload\";\n  }\n  \n  return {\n    painLevel,\n    consciousnessLevel,\n    isInPainOverload,\n    isIncapacitated,\n    isCombatEffective,\n    combatEffectiveness,\n    statusDescription: {\n      korean: statusKorean,\n      english: statusEnglish,\n    },\n  };\n}\n\n/**\n * Determines if a combat result should trigger head trauma.\n * \n * Head trauma occurs for:\n * - Neurological vital point hits\n * - Vascular hits to head region\n * - High damage hits (>25) that could cause concussion\n * - Critical hits to upper body\n * \n * @param result - Combat result to check\n * @param category - Vital point category if known\n * @returns True if result should cause head trauma\n * \n * @public\n * @korean 두부외상확인\n */\nexport function isHeadTraumaHit(\n  result: CombatResult,\n  category?: VitalPointCategory\n): boolean {\n  // Neurological hits often target head\n  if (category === VitalPointCategory.NEUROLOGICAL) {\n    return true;\n  }\n  \n  // Vascular hits to head region\n  if (category === VitalPointCategory.VASCULAR && result.damage > 15) {\n    return true;\n  }\n  \n  // High damage hits that could concuss\n  if (result.damage > 25) {\n    return true;\n  }\n  \n  // Critical hits to vital points\n  if (result.isCritical && result.vitalPointHit) {\n    return true;\n  }\n  \n  return false;\n}\n\n/**\n * Extracts vital point category from combat result.\n * \n * Uses heuristics to determine category from effect sources and hit data.\n * \n * @param result - Combat result\n * @returns Vital point category if determinable\n * \n * @public\n * @korean 급소분류추출\n */\nexport function extractVitalPointCategory(result: CombatResult): VitalPointCategory | undefined {\n  if (!result.vitalPointHit || !result.effects || result.effects.length === 0) {\n    return undefined;\n  }\n  \n  const effect = result.effects[0];\n  if (!effect.source) {\n    return undefined;\n  }\n  \n  const source = effect.source.toLowerCase();\n  \n  // Map source strings to categories\n  if (source.includes('neuro') || source.includes('nerve')) {\n    return VitalPointCategory.NEUROLOGICAL;\n  }\n  if (source.includes('vascular') || source.includes('blood') || source.includes('artery')) {\n    return VitalPointCategory.VASCULAR;\n  }\n  if (source.includes('respiratory') || source.includes('breath') || source.includes('lung')) {\n    return VitalPointCategory.RESPIRATORY;\n  }\n  if (source.includes('skeletal') || source.includes('bone')) {\n    return VitalPointCategory.SKELETAL;\n  }\n  if (source.includes('muscular') || source.includes('muscle')) {\n    return VitalPointCategory.MUSCULAR;\n  }\n  if (source.includes('organ') || source.includes('visceral')) {\n    return VitalPointCategory.ORGAN;\n  }\n  if (source.includes('joint')) {\n    return VitalPointCategory.JOINT;\n  }\n  \n  return undefined;\n}\n\n/**\n * Calculates recommended recovery time based on player condition.\n * \n * @param player - Player state\n * @param consciousnessSystem - Consciousness system\n * @returns Estimated recovery time in seconds\n * \n * @example\n * ```typescript\n * const recoveryTime = getRecommendedRecoveryTime(player, consciousnessSystem);\n * console.log(`Recovery needed: ${recoveryTime}s`);\n * ```\n * \n * @public\n * @korean 회복시간계산\n */\nexport function getRecommendedRecoveryTime(\n  player: PlayerState,\n  consciousnessSystem: ConsciousnessSystem\n): number {\n  let painRecoveryTime = 0;\n  let consciousnessRecoveryTime = 0;\n  \n  // Pain recovery time (-5 pain/second)\n  if (player.pain > 0) {\n    painRecoveryTime = player.pain / 5;\n  }\n  \n  // Consciousness recovery time (5 points/second after 5s delay)\n  if (player.consciousness < 100) {\n    const consciousnessToRecover = 100 - player.consciousness;\n    const consciousnessLevel = consciousnessSystem.getLevel(player.consciousness);\n    \n    // Account for slower recovery at low consciousness\n    let recoveryRate = 5; // Base rate\n    if (consciousnessLevel === ConsciousnessLevel.STUNNED) {\n      recoveryRate = 2.5; // 50% slower\n    } else if (consciousnessLevel === ConsciousnessLevel.UNCONSCIOUS) {\n      recoveryRate = 1; // 20% of base\n    }\n    \n    consciousnessRecoveryTime = 5 + (consciousnessToRecover / recoveryRate);\n  }\n  \n  // Since pain and consciousness recover in parallel (concurrently in game loop),\n  // return the maximum of the two recovery times, not the sum\n  return Math.ceil(Math.max(painRecoveryTime, consciousnessRecoveryTime));\n}\n\n/**\n * Checks if shock pain effect is still active.\n * \n * @param shockEffect - Shock pain effect to check\n * @returns True if effect is still active\n * \n * @public\n * @korean 충격통활성확인\n */\nexport function isShockPainActive(shockEffect: ShockPainEffect): boolean {\n  const elapsed = Date.now() - shockEffect.startTime;\n  return elapsed < shockEffect.duration;\n}\n\n/**\n * Gets remaining shock pain duration.\n * \n * @param shockEffect - Shock pain effect\n * @returns Remaining duration in milliseconds, or 0 if expired\n * \n * @public\n * @korean 충격통잔여시간\n */\nexport function getShockPainRemainingDuration(shockEffect: ShockPainEffect): number {\n  const elapsed = Date.now() - shockEffect.startTime;\n  return Math.max(0, shockEffect.duration - elapsed);\n}\n\n/**\n * Formats pain and consciousness values for display.\n * \n * @param player - Player state\n * @returns Formatted display strings\n * \n * @example\n * ```typescript\n * const display = formatPainConsciousnessDisplay(player);\n * console.log(display.pain); // \"Pain: 45/100\"\n * console.log(display.consciousness); // \"Consciousness: 85/100\"\n * ```\n * \n * @public\n * @korean 표시형식\n */\nexport function formatPainConsciousnessDisplay(player: PlayerState): {\n  readonly pain: string;\n  readonly consciousness: string;\n  readonly painKorean: string;\n  readonly consciousnessKorean: string;\n} {\n  return {\n    pain: `Pain: ${Math.floor(player.pain)}/100`,\n    consciousness: `Consciousness: ${Math.floor(player.consciousness)}/100`,\n    painKorean: `고통: ${Math.floor(player.pain)}/100`,\n    consciousnessKorean: `의식: ${Math.floor(player.consciousness)}/100`,\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AA4DA,SAAgB,2BACd,QACA,YACA,qBACyB;CACzB,MAAM,YAAY,WAAW,aAAa,OAAO,KAAK;CACtD,MAAM,qBAAqB,oBAAoB,SAAS,OAAO,cAAc;CAE7E,MAAM,mBAAmB,WAAW,iBAAiB,OAAO;CAC5D,MAAM,kBAAkB,oBAAoB,4BAA4B,OAAO;CAG/E,MAAM,cAAc,WAAW,WAAW,UAAU,CAAC;CACrD,MAAM,uBAAuB,oBAAoB,WAAW,mBAAmB,CAAC;CAChF,MAAM,sBAAsB,KAAK,IAAI,GAAG,IAAI,KAAK,IAAI,aAAa,qBAAqB,CAAC;CAExF,MAAM,oBAAoB,sBAAsB;CAGhD,MAAM,WAAW,WAAW,aAAa,UAAU;CACnD,MAAM,oBAAoB,oBAAoB,aAAa,mBAAmB;CAE9E,IAAI,eAAe,OAAO,SAAS,OAAO,QAAQ,kBAAkB;CACpE,IAAI,gBAAgB,SAAS,SAAS,QAAQ,mBAAmB,kBAAkB;AAEnF,KAAI,iBAAiB;AACnB,iBAAe;AACf,kBAAgB;YACP,kBAAkB;AAC3B,iBAAe;AACf,kBAAgB;;AAGlB,QAAO;EACL;EACA;EACA;EACA;EACA;EACA;EACA,mBAAmB;GACjB,QAAQ;GACR,SAAS;GACV;EACF;;;;;;;;;;;;;;;;;;AAmBH,SAAgB,gBACd,QACA,UACS;AAET,KAAI,aAAa,mBAAmB,aAClC,QAAO;AAIT,KAAI,aAAa,mBAAmB,YAAY,OAAO,SAAS,GAC9D,QAAO;AAIT,KAAI,OAAO,SAAS,GAClB,QAAO;AAIT,KAAI,OAAO,cAAc,OAAO,cAC9B,QAAO;AAGT,QAAO;;;;;;;;;;;;;AAcT,SAAgB,0BAA0B,QAAsD;AAC9F,KAAI,CAAC,OAAO,iBAAiB,CAAC,OAAO,WAAW,OAAO,QAAQ,WAAW,EACxE;CAGF,MAAM,SAAS,OAAO,QAAQ;AAC9B,KAAI,CAAC,OAAO,OACV;CAGF,MAAM,SAAS,OAAO,OAAO,aAAa;AAG1C,KAAI,OAAO,SAAS,QAAQ,IAAI,OAAO,SAAS,QAAQ,CACtD,QAAO,mBAAmB;AAE5B,KAAI,OAAO,SAAS,WAAW,IAAI,OAAO,SAAS,QAAQ,IAAI,OAAO,SAAS,SAAS,CACtF,QAAO,mBAAmB;AAE5B,KAAI,OAAO,SAAS,cAAc,IAAI,OAAO,SAAS,SAAS,IAAI,OAAO,SAAS,OAAO,CACxF,QAAO,mBAAmB;AAE5B,KAAI,OAAO,SAAS,WAAW,IAAI,OAAO,SAAS,OAAO,CACxD,QAAO,mBAAmB;AAE5B,KAAI,OAAO,SAAS,WAAW,IAAI,OAAO,SAAS,SAAS,CAC1D,QAAO,mBAAmB;AAE5B,KAAI,OAAO,SAAS,QAAQ,IAAI,OAAO,SAAS,WAAW,CACzD,QAAO,mBAAmB;AAE5B,KAAI,OAAO,SAAS,QAAQ,CAC1B,QAAO,mBAAmB;;;;;;;;;;;;;;;;;;AAsB9B,SAAgB,2BACd,QACA,qBACQ;CACR,IAAI,mBAAmB;CACvB,IAAI,4BAA4B;AAGhC,KAAI,OAAO,OAAO,EAChB,oBAAmB,OAAO,OAAO;AAInC,KAAI,OAAO,gBAAgB,KAAK;EAC9B,MAAM,yBAAyB,MAAM,OAAO;EAC5C,MAAM,qBAAqB,oBAAoB,SAAS,OAAO,cAAc;EAG7E,IAAI,eAAe;AACnB,MAAI,uBAAuB,mBAAmB,QAC5C,gBAAe;WACN,uBAAuB,mBAAmB,YACnD,gBAAe;AAGjB,8BAA4B,IAAK,yBAAyB;;AAK5D,QAAO,KAAK,KAAK,KAAK,IAAI,kBAAkB,0BAA0B,CAAC;;;;;;;;;;;AAYzE,SAAgB,kBAAkB,aAAuC;AAEvE,QADgB,KAAK,KAAK,GAAG,YAAY,YACxB,YAAY;;;;;;;;;;;AAY/B,SAAgB,8BAA8B,aAAsC;CAClF,MAAM,UAAU,KAAK,KAAK,GAAG,YAAY;AACzC,QAAO,KAAK,IAAI,GAAG,YAAY,WAAW,QAAQ;;;;;;;;;;;;;;;;;;AAmBpD,SAAgB,+BAA+B,QAK7C;AACA,QAAO;EACL,MAAM,SAAS,KAAK,MAAM,OAAO,KAAK,CAAC;EACvC,eAAe,kBAAkB,KAAK,MAAM,OAAO,cAAc,CAAC;EAClE,YAAY,OAAO,KAAK,MAAM,OAAO,KAAK,CAAC;EAC3C,qBAAqB,OAAO,KAAK,MAAM,OAAO,cAAc,CAAC;EAC9D"}