blacktrigram 0.7.2

package/lib/systems/combat/ConsciousnessSystem.js

@@ -0,0 +1,529 @@
+import { VitalPointCategory } from "../../types/common.js";
+import "../../types/index.js";
+import { determineFallFromStance } from "../animation/systems/FallAnimations.js";
+import "../animation/index.js";
+//#region src/systems/combat/ConsciousnessSystem.ts
+/**
+* Consciousness System for managing awareness and cognitive function levels.
+*
+* **Korean**: 의식 시스템 (Consciousness System)
+*
+* Implements consciousness levels based on head trauma, blood flow restriction,
+* and neural damage. Consciousness affects reaction time, targeting precision,
+* and overall combat effectiveness.
+*
+* ## Consciousness Levels
+*
+* - **전투각성 (Combat Alert)**: 100% - Full awareness, optimal combat ability
+* - **혼란상태 (Disoriented)**: 70% - Reduced reaction, vulnerability window
+* - **기절직전 (Stunned)**: 40% - Severe impairment, incapacitation opportunity
+* - **무의식 (Unconscious)**: 0% - Complete incapacitation
+*
+* ## Fall System Integration
+*
+* When consciousness drops below 10%, the system triggers fall animations (낙법).
+* The character loses the ability to stand and collapses to the ground.
+* Fall direction is based on last impact location.
+*
+* @module systems/combat/ConsciousnessSystem
+* @category Combat System
+* @korean 의식시스템
+*/
+/**
+* Consciousness levels representing cognitive function and awareness.
+*
+* **Korean**: 의식 수준
+*/
+var ConsciousnessLevel = /* @__PURE__ */ function(ConsciousnessLevel) {
+	/** Full combat awareness (90-100%) */
+	ConsciousnessLevel["COMBAT_ALERT"] = "combat_alert";
+	/** Disoriented and vulnerable (50-89%) */
+	ConsciousnessLevel["DISORIENTED"] = "disoriented";
+	/** Severely stunned (10-49%) */
+	ConsciousnessLevel["STUNNED"] = "stunned";
+	/** Completely unconscious (0-9%) */
+	ConsciousnessLevel["UNCONSCIOUS"] = "unconscious";
+	return ConsciousnessLevel;
+}({});
+/**
+* Consciousness System managing awareness and cognitive function.
+*
+* Tracks consciousness damage from:
+* - Head trauma (strikes to head region)
+* - Neurological vital point hits
+* - Blood flow restriction (vascular hits)
+* - Respiratory disruption
+*
+* Consciousness naturally recovers over time when not taking damage.
+*
+* @example
+* ```typescript
+* const consciousnessSystem = new ConsciousnessSystem();
+*
+* // Apply damage from head strike
+* const newPlayer = consciousnessSystem.applyDamage(
+*   player,
+*   15,
+*   VitalPointCategory.NEUROLOGICAL
+* );
+*
+* // Check consciousness level
+* const level = consciousnessSystem.getLevel(newPlayer.consciousness);
+* console.log(`Consciousness: ${level}`);
+*
+* // Apply recovery over time
+* const recovered = consciousnessSystem.applyRecovery(newPlayer, 1000);
+* ```
+*
+* @public
+* @korean 의식시스템
+*/
+var ConsciousnessSystem = class {
+	/**
+	* Consciousness level effects and thresholds.
+	*/
+	levelEffects = {
+		[ConsciousnessLevel.COMBAT_ALERT]: {
+			range: [90, 100],
+			reactionTimeMultiplier: 1,
+			accuracyPenalty: 0,
+			defensePenalty: 0,
+			canAct: true,
+			visionClarity: 1
+		},
+		[ConsciousnessLevel.DISORIENTED]: {
+			range: [50, 89],
+			reactionTimeMultiplier: 1.3,
+			accuracyPenalty: .2,
+			defensePenalty: .15,
+			canAct: true,
+			visionClarity: .7
+		},
+		[ConsciousnessLevel.STUNNED]: {
+			range: [20, 49],
+			reactionTimeMultiplier: 2,
+			accuracyPenalty: .5,
+			defensePenalty: .4,
+			canAct: true,
+			visionClarity: .4
+		},
+		[ConsciousnessLevel.UNCONSCIOUS]: {
+			range: [0, 19],
+			reactionTimeMultiplier: Infinity,
+			accuracyPenalty: 1,
+			defensePenalty: 1,
+			canAct: false,
+			visionClarity: 0
+		}
+	};
+	/**
+	* Damage multipliers by vital point category affecting consciousness.
+	*/
+	categoryMultipliers = {
+		[VitalPointCategory.NEUROLOGICAL]: 3,
+		[VitalPointCategory.VASCULAR]: 2,
+		[VitalPointCategory.RESPIRATORY]: 1.5,
+		default: .5
+	};
+	/**
+	* Base recovery rate per second.
+	*/
+	baseRecoveryRate = 5;
+	/**
+	* Incapacitation threshold - consciousness <20% renders player helpless.
+	*
+	* **Korean**: 무력화한계 (Incapacitation Threshold)
+	*/
+	incapacitationThreshold = 20;
+	/**
+	* Duration of helplessness when consciousness drops below threshold (3-5 seconds).
+	*/
+	helplessDuration = {
+		min: 3e3,
+		max: 5e3
+	};
+	/**
+	* Time without head trauma required for consciousness recovery (5 seconds).
+	*/
+	noTraumaRecoveryTime = 5e3;
+	/**
+	* Applies consciousness damage from combat.
+	*
+	* Calculates consciousness reduction based on damage amount and
+	* vital point category. Neurological and vascular damage have
+	* the highest impact on consciousness.
+	*
+	* @param player - Current player state
+	* @param damage - Base damage amount
+	* @param category - Vital point category hit
+	* @returns Updated player state with reduced consciousness
+	*
+	* @example
+	* ```typescript
+	* // Head strike causes significant consciousness damage
+	* const newPlayer = system.applyDamage(
+	*   player,
+	*   20,
+	*   VitalPointCategory.NEUROLOGICAL
+	* );
+	* console.log(`Consciousness: ${newPlayer.consciousness}`);
+	* ```
+	*
+	* @public
+	* @korean 의식피해적용
+	*/
+	applyDamage(player, damage, category) {
+		const consciousnessDamage = damage * (category ? this.categoryMultipliers[category] ?? this.categoryMultipliers.default : this.categoryMultipliers.default);
+		const newConsciousness = Math.max(0, Math.min(100, player.consciousness - consciousnessDamage));
+		return {
+			...player,
+			consciousness: newConsciousness
+		};
+	}
+	/**
+	* Applies consciousness recovery over time.
+	*
+	* Consciousness naturally recovers when not taking damage.
+	* Recovery rate depends on current level - severely stunned
+	* players recover more slowly.
+	*
+	* **Note**: Full recovery only occurs after 5 seconds without head trauma.
+	*
+	* @param player - Current player state
+	* @param deltaTime - Time elapsed in milliseconds
+	* @param lastHeadTraumaTime - Timestamp of last head trauma (optional)
+	* @returns Updated player state with recovered consciousness
+	*
+	* @example
+	* ```typescript
+	* // In game loop (60fps, ~16ms per frame)
+	* player = system.applyRecovery(player, 16, player.lastActionTime);
+	* ```
+	*
+	* @public
+	* @korean 의식회복
+	*/
+	applyRecovery(player, deltaTime, lastHeadTraumaTime) {
+		if (player.consciousness >= 100) return player;
+		if ((lastHeadTraumaTime ? Date.now() - lastHeadTraumaTime : Infinity) < this.noTraumaRecoveryTime) return player;
+		const deltaSeconds = deltaTime / 1e3;
+		const level = this.getLevel(player.consciousness);
+		let recoveryModifier = 1;
+		if (level === ConsciousnessLevel.STUNNED) recoveryModifier = .5;
+		else if (level === ConsciousnessLevel.UNCONSCIOUS) recoveryModifier = .2;
+		const recovery = this.baseRecoveryRate * deltaSeconds * recoveryModifier;
+		const newConsciousness = Math.min(100, player.consciousness + recovery);
+		return {
+			...player,
+			consciousness: newConsciousness
+		};
+	}
+	/**
+	* Determines consciousness level from consciousness value.
+	*
+	* Updated thresholds:
+	* - 90-100: Combat Alert
+	* - 50-89: Disoriented
+	* - 20-49: Stunned
+	* - 0-19: Unconscious (incapacitation threshold <20%)
+	*
+	* @param consciousness - Consciousness value (0-100)
+	* @returns Current consciousness level
+	*
+	* @example
+	* ```typescript
+	* const level = system.getLevel(75);
+	* console.log(level); // DISORIENTED
+	*
+	* const level2 = system.getLevel(15);
+	* console.log(level2); // UNCONSCIOUS (below incapacitation threshold)
+	* ```
+	*
+	* @public
+	* @korean 의식수준확인
+	*/
+	getLevel(consciousness) {
+		if (consciousness >= 90) return ConsciousnessLevel.COMBAT_ALERT;
+		if (consciousness >= 50) return ConsciousnessLevel.DISORIENTED;
+		if (consciousness >= 20) return ConsciousnessLevel.STUNNED;
+		return ConsciousnessLevel.UNCONSCIOUS;
+	}
+	/**
+	* Gets effects for a specific consciousness level.
+	*
+	* @param level - Consciousness level
+	* @returns Effects applied at that level
+	*
+	* @public
+	* @korean 의식효과
+	*/
+	getEffects(level) {
+		return this.levelEffects[level];
+	}
+	/**
+	* Applies consciousness effects to player state.
+	*
+	* Modifies player stats based on current consciousness level.
+	*
+	* @param player - Current player state
+	* @returns Modified player state with consciousness effects
+	*
+	* @public
+	* @korean 의식효과적용
+	*/
+	applyEffects(player) {
+		const level = this.getLevel(player.consciousness);
+		const effects = this.getEffects(level);
+		return {
+			...player,
+			attackPower: Math.floor(player.attackPower * (1 - effects.accuracyPenalty)),
+			defense: Math.floor(player.defense * (1 - effects.defensePenalty)),
+			technique: Math.floor(player.technique * (1 - effects.accuracyPenalty)),
+			isStunned: player.isStunned || level === ConsciousnessLevel.UNCONSCIOUS || level === ConsciousnessLevel.STUNNED
+		};
+	}
+	/**
+	* Checks if player is at incapacitation threshold.
+	*
+	* **Korean**: 무력화한계 (Incapacitation Threshold)
+	*
+	* When consciousness drops below 20%, player becomes helpless for 3-5 seconds.
+	*
+	* @param player - Current player state
+	* @returns True if consciousness is below incapacitation threshold (<20%)
+	*
+	* @example
+	* ```typescript
+	* if (system.isAtIncapacitationThreshold(player)) {
+	*   // Player is helpless, trigger helpless state
+	*   const helplessDuration = system.getHelplessDuration();
+	*   console.log(`Player helpless for ${helplessDuration}ms`);
+	* }
+	* ```
+	*
+	* @public
+	* @korean 무력화한계확인
+	*/
+	isAtIncapacitationThreshold(player) {
+		return player.consciousness < this.incapacitationThreshold;
+	}
+	/**
+	* Gets random helpless duration when consciousness drops below threshold.
+	*
+	* Returns a random duration between 3-5 seconds (3000-5000ms).
+	*
+	* @returns Helpless duration in milliseconds
+	*
+	* @public
+	* @korean 무력화지속시간
+	*/
+	getHelplessDuration() {
+		return this.helplessDuration.min + Math.random() * (this.helplessDuration.max - this.helplessDuration.min);
+	}
+	/**
+	* Checks if enough time has passed for consciousness recovery.
+	*
+	* Consciousness only recovers after 5 seconds without head trauma.
+	*
+	* @param lastHeadTraumaTime - Timestamp of last head trauma
+	* @returns True if recovery is allowed
+	*
+	* @public
+	* @korean 회복가능확인
+	*/
+	canRecover(lastHeadTraumaTime) {
+		return Date.now() - lastHeadTraumaTime >= this.noTraumaRecoveryTime;
+	}
+	/**
+	* Checks if player is incapacitated due to consciousness.
+	*
+	* @param player - Current player state
+	* @returns True if player is unconscious
+	*
+	* @public
+	* @korean 무의식확인
+	*/
+	isIncapacitated(player) {
+		return this.getLevel(player.consciousness) === ConsciousnessLevel.UNCONSCIOUS;
+	}
+	/**
+	* Gets bilingual name for consciousness level.
+	*
+	* @param level - Consciousness level
+	* @returns Korean and English level names
+	*
+	* @public
+	* @korean 의식이름
+	*/
+	getLevelName(level) {
+		return {
+			[ConsciousnessLevel.COMBAT_ALERT]: {
+				korean: "전투각성",
+				english: "Combat Alert"
+			},
+			[ConsciousnessLevel.DISORIENTED]: {
+				korean: "혼란상태",
+				english: "Disoriented"
+			},
+			[ConsciousnessLevel.STUNNED]: {
+				korean: "기절직전",
+				english: "Stunned"
+			},
+			[ConsciousnessLevel.UNCONSCIOUS]: {
+				korean: "무의식",
+				english: "Unconscious"
+			}
+		}[level];
+	}
+	/**
+	* Gets description of consciousness level effects.
+	*
+	* @param level - Consciousness level
+	* @returns Bilingual description
+	*
+	* @public
+	* @korean 의식설명
+	*/
+	getLevelDescription(level) {
+		return {
+			[ConsciousnessLevel.COMBAT_ALERT]: {
+				korean: "완전한 의식과 전투 능력",
+				english: "Full awareness and combat ability"
+			},
+			[ConsciousnessLevel.DISORIENTED]: {
+				korean: "반응 시간 저하 및 혼란",
+				english: "Reduced reaction time and confusion"
+			},
+			[ConsciousnessLevel.STUNNED]: {
+				korean: "심각한 손상, 무력화 위험",
+				english: "Severe impairment, incapacitation risk"
+			},
+			[ConsciousnessLevel.UNCONSCIOUS]: {
+				korean: "완전한 무의식 상태",
+				english: "Complete unconsciousness"
+			}
+		}[level];
+	}
+	/**
+	* Gets color indicator for consciousness level (for UI).
+	*
+	* @param level - Consciousness level
+	* @returns Hex color code
+	*
+	* @public
+	* @korean 의식색상
+	*/
+	getLevelColor(level) {
+		return {
+			[ConsciousnessLevel.COMBAT_ALERT]: 65280,
+			[ConsciousnessLevel.DISORIENTED]: 16755200,
+			[ConsciousnessLevel.STUNNED]: 16729088,
+			[ConsciousnessLevel.UNCONSCIOUS]: 16711680
+		}[level];
+	}
+	/**
+	* Checks if consciousness is low enough to trigger fall animation.
+	*
+	* Falls occur when consciousness drops below 10% (UNCONSCIOUS threshold).
+	* This represents complete loss of ability to maintain standing position.
+	*
+	* Korean terminology:
+	* - 의식상실낙법 (Uisik Sangsil Nakbeop): Consciousness loss fall
+	* - 기절낙하 (Gijeol Nakha): Knockout collapse
+	*
+	* @param player - Current player state
+	* @returns True if fall animation should trigger
+	*
+	* @example
+	* ```typescript
+	* if (consciousnessSystem.shouldTriggerFall(player)) {
+	*   const fallType = consciousnessSystem.determineFallType(
+	*     player,
+	*     lastImpactAngle
+	*   );
+	*   animationMachine.transitionTo(FALL_TYPE_TO_ANIMATION[fallType]);
+	* }
+	* ```
+	*
+	* @public
+	* @korean 의식상실낙법확인
+	*/
+	shouldTriggerFall(player) {
+		return player.consciousness < 10;
+	}
+	/**
+	* Determines fall direction based on last impact and stance.
+	*
+	* When consciousness is lost, fall direction is determined by:
+	* - Last attack angle (if available)
+	* - Current stance bias (if no attack data)
+	* - Default to backward fall (natural collapse)
+	*
+	* Korean falling from consciousness loss:
+	* - 후방의식상실 (Hubang Uisik Sangsil): Backward consciousness loss fall
+	* - 전방기절 (Jeonbang Gijeol): Forward knockout
+	*
+	* @param player - Current player state
+	* @param lastImpactAngle - Angle of last hit (optional)
+	* @returns Fall type to use for animation
+	*
+	* @example
+	* ```typescript
+	* // Player loses consciousness from frontal head strike
+	* const fallType = consciousnessSystem.determineFallType(
+	*   player,
+	*   0 // Front angle
+	* );
+	* // Returns: 'backward' (knocked back by frontal strike)
+	*
+	* // Player loses consciousness without specific impact
+	* const fallType = consciousnessSystem.determineFallType(player);
+	* // Returns: Stance-based fall or 'backward' default
+	* ```
+	*
+	* @public
+	* @korean 의식상실낙법결정
+	*/
+	determineFallType(_player, lastImpactAngle) {
+		if (lastImpactAngle !== void 0) {
+			const normalizedAngle = Math.abs(lastImpactAngle);
+			if (normalizedAngle < Math.PI / 4) return "backward";
+			if (normalizedAngle > 3 * Math.PI / 4) return "forward";
+			if (lastImpactAngle < 0) return "side_left";
+			if (lastImpactAngle > 0) return "side_right";
+			return "backward";
+		}
+		return "backward";
+	}
+	/**
+	* Determines fall type based on stance when consciousness is lost.
+	*
+	* Uses stance bias to determine fall direction when consciousness
+	* is lost without specific impact data.
+	*
+	* Korean terminology:
+	* - 자세의식상실 (Jase Uisik Sangsil): Stance-based consciousness loss
+	*
+	* @param stance - Current trigram stance
+	* @returns Fall type based on stance characteristics
+	*
+	* @example
+	* ```typescript
+	* // Player in Mountain stance (defensive back)
+	* const fallType = consciousnessSystem.determineFallTypeFromStance(
+	*   TrigramStance.GAN
+	* );
+	* // Returns: 'backward' (Mountain has defensive backward bias)
+	* ```
+	*
+	* @public
+	* @korean 자세의식상실낙법
+	*/
+	determineFallTypeFromStance(stance) {
+		return determineFallFromStance(stance, "backward");
+	}
+};
+//#endregion
+export { ConsciousnessLevel, ConsciousnessSystem as default };
+
+//# sourceMappingURL=ConsciousnessSystem.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ConsciousnessSystem.js","names":[],"sources":["../../../src/systems/combat/ConsciousnessSystem.ts"],"sourcesContent":["/**\n * Consciousness System for managing awareness and cognitive function levels.\n *\n * **Korean**: 의식 시스템 (Consciousness System)\n *\n * Implements consciousness levels based on head trauma, blood flow restriction,\n * and neural damage. Consciousness affects reaction time, targeting precision,\n * and overall combat effectiveness.\n *\n * ## Consciousness Levels\n *\n * - **전투각성 (Combat Alert)**: 100% - Full awareness, optimal combat ability\n * - **혼란상태 (Disoriented)**: 70% - Reduced reaction, vulnerability window\n * - **기절직전 (Stunned)**: 40% - Severe impairment, incapacitation opportunity\n * - **무의식 (Unconscious)**: 0% - Complete incapacitation\n *\n * ## Fall System Integration\n *\n * When consciousness drops below 10%, the system triggers fall animations (낙법).\n * The character loses the ability to stand and collapses to the ground.\n * Fall direction is based on last impact location.\n *\n * @module systems/combat/ConsciousnessSystem\n * @category Combat System\n * @korean 의식시스템\n */\n\nimport { VitalPointCategory } from \"@/types\";\nimport type { TrigramStance } from \"@/types/common\";\nimport { determineFallFromStance } from \"../animation\";\nimport type { FallType } from \"../animation/core/types\";\nimport { PlayerState } from \"../player\";\n\n/**\n * Consciousness levels representing cognitive function and awareness.\n *\n * **Korean**: 의식 수준\n */\nexport enum ConsciousnessLevel {\n  /** Full combat awareness (90-100%) */\n  COMBAT_ALERT = \"combat_alert\",\n  /** Disoriented and vulnerable (50-89%) */\n  DISORIENTED = \"disoriented\",\n  /** Severely stunned (10-49%) */\n  STUNNED = \"stunned\",\n  /** Completely unconscious (0-9%) */\n  UNCONSCIOUS = \"unconscious\",\n}\n\n/**\n * Effects of consciousness levels on combat performance.\n */\ninterface ConsciousnessEffects {\n  /** Consciousness value range */\n  readonly range: readonly [number, number];\n  /** Reaction time multiplier */\n  readonly reactionTimeMultiplier: number;\n  /** Accuracy penalty */\n  readonly accuracyPenalty: number;\n  /** Defense penalty */\n  readonly defensePenalty: number;\n  /** Can perform actions */\n  readonly canAct: boolean;\n  /** Vision clarity multiplier */\n  readonly visionClarity: number;\n}\n\n/**\n * Consciousness System managing awareness and cognitive function.\n *\n * Tracks consciousness damage from:\n * - Head trauma (strikes to head region)\n * - Neurological vital point hits\n * - Blood flow restriction (vascular hits)\n * - Respiratory disruption\n *\n * Consciousness naturally recovers over time when not taking damage.\n *\n * @example\n * ```typescript\n * const consciousnessSystem = new ConsciousnessSystem();\n *\n * // Apply damage from head strike\n * const newPlayer = consciousnessSystem.applyDamage(\n *   player,\n *   15,\n *   VitalPointCategory.NEUROLOGICAL\n * );\n *\n * // Check consciousness level\n * const level = consciousnessSystem.getLevel(newPlayer.consciousness);\n * console.log(`Consciousness: ${level}`);\n *\n * // Apply recovery over time\n * const recovered = consciousnessSystem.applyRecovery(newPlayer, 1000);\n * ```\n *\n * @public\n * @korean 의식시스템\n */\nexport class ConsciousnessSystem {\n  /**\n   * Consciousness level effects and thresholds.\n   */\n  private readonly levelEffects: Record<\n    ConsciousnessLevel,\n    ConsciousnessEffects\n  > = {\n    [ConsciousnessLevel.COMBAT_ALERT]: {\n      range: [90, 100],\n      reactionTimeMultiplier: 1.0,\n      accuracyPenalty: 0.0,\n      defensePenalty: 0.0,\n      canAct: true,\n      visionClarity: 1.0,\n    },\n    [ConsciousnessLevel.DISORIENTED]: {\n      range: [50, 89],\n      reactionTimeMultiplier: 1.3, // 30% slower reactions\n      accuracyPenalty: 0.2, // -20% accuracy\n      defensePenalty: 0.15, // -15% defense\n      canAct: true,\n      visionClarity: 0.7,\n    },\n    [ConsciousnessLevel.STUNNED]: {\n      range: [20, 49], // Updated: Changed from [10, 49] to [20, 49]\n      reactionTimeMultiplier: 2.0, // 2x slower reactions\n      accuracyPenalty: 0.5, // -50% accuracy\n      defensePenalty: 0.4, // -40% defense\n      canAct: true,\n      visionClarity: 0.4,\n    },\n    [ConsciousnessLevel.UNCONSCIOUS]: {\n      range: [0, 19], // Updated: Changed from [0, 9] to [0, 19] - incapacitation threshold <20%\n      reactionTimeMultiplier: Infinity,\n      accuracyPenalty: 1.0, // Complete inability\n      defensePenalty: 1.0, // No defense\n      canAct: false,\n      visionClarity: 0.0,\n    },\n  };\n\n  /**\n   * Damage multipliers by vital point category affecting consciousness.\n   */\n  private readonly categoryMultipliers: Record<string, number> = {\n    [VitalPointCategory.NEUROLOGICAL]: 3.0, // Nerve strikes heavily affect consciousness\n    [VitalPointCategory.VASCULAR]: 2.0, // Blood flow restriction\n    [VitalPointCategory.RESPIRATORY]: 1.5, // Breathing difficulty\n    default: 0.5, // Other damage has minor effect\n  };\n\n  /**\n   * Base recovery rate per second.\n   */\n  private readonly baseRecoveryRate = 5.0; // 5 points per second\n\n  /**\n   * Incapacitation threshold - consciousness <20% renders player helpless.\n   *\n   * **Korean**: 무력화한계 (Incapacitation Threshold)\n   */\n  private readonly incapacitationThreshold = 20;\n\n  /**\n   * Duration of helplessness when consciousness drops below threshold (3-5 seconds).\n   */\n  private readonly helplessDuration = {\n    min: 3000, // 3 seconds\n    max: 5000, // 5 seconds\n  };\n\n  /**\n   * Time without head trauma required for consciousness recovery (5 seconds).\n   */\n  private readonly noTraumaRecoveryTime = 5000; // 5 seconds\n\n  /**\n   * Applies consciousness damage from combat.\n   *\n   * Calculates consciousness reduction based on damage amount and\n   * vital point category. Neurological and vascular damage have\n   * the highest impact on consciousness.\n   *\n   * @param player - Current player state\n   * @param damage - Base damage amount\n   * @param category - Vital point category hit\n   * @returns Updated player state with reduced consciousness\n   *\n   * @example\n   * ```typescript\n   * // Head strike causes significant consciousness damage\n   * const newPlayer = system.applyDamage(\n   *   player,\n   *   20,\n   *   VitalPointCategory.NEUROLOGICAL\n   * );\n   * console.log(`Consciousness: ${newPlayer.consciousness}`);\n   * ```\n   *\n   * @public\n   * @korean 의식피해적용\n   */\n  applyDamage(\n    player: PlayerState,\n    damage: number,\n    category?: VitalPointCategory\n  ): PlayerState {\n    // Get multiplier based on category\n    const multiplier = category\n      ? this.categoryMultipliers[category] ?? this.categoryMultipliers.default\n      : this.categoryMultipliers.default;\n\n    // Calculate consciousness damage\n    const consciousnessDamage = damage * multiplier;\n\n    // Apply damage, clamped to 0-100 range\n    const newConsciousness = Math.max(\n      0,\n      Math.min(100, player.consciousness - consciousnessDamage)\n    );\n\n    return {\n      ...player,\n      consciousness: newConsciousness,\n    };\n  }\n\n  /**\n   * Applies consciousness recovery over time.\n   *\n   * Consciousness naturally recovers when not taking damage.\n   * Recovery rate depends on current level - severely stunned\n   * players recover more slowly.\n   *\n   * **Note**: Full recovery only occurs after 5 seconds without head trauma.\n   *\n   * @param player - Current player state\n   * @param deltaTime - Time elapsed in milliseconds\n   * @param lastHeadTraumaTime - Timestamp of last head trauma (optional)\n   * @returns Updated player state with recovered consciousness\n   *\n   * @example\n   * ```typescript\n   * // In game loop (60fps, ~16ms per frame)\n   * player = system.applyRecovery(player, 16, player.lastActionTime);\n   * ```\n   *\n   * @public\n   * @korean 의식회복\n   */\n  applyRecovery(\n    player: PlayerState,\n    deltaTime: number,\n    lastHeadTraumaTime?: number\n  ): PlayerState {\n    // Already at full consciousness\n    if (player.consciousness >= 100) {\n      return player;\n    }\n\n    // Check if enough time has passed since last head trauma\n    const timeSinceTrauma = lastHeadTraumaTime\n      ? Date.now() - lastHeadTraumaTime\n      : Infinity;\n\n    // Don't recover if head trauma is recent (within 5 seconds)\n    if (timeSinceTrauma < this.noTraumaRecoveryTime) {\n      return player;\n    }\n\n    // Calculate recovery based on time\n    const deltaSeconds = deltaTime / 1000;\n    const level = this.getLevel(player.consciousness);\n\n    // Recovery rate modifier based on level\n    let recoveryModifier = 1.0;\n    if (level === ConsciousnessLevel.STUNNED) {\n      recoveryModifier = 0.5; // Slower recovery when stunned\n    } else if (level === ConsciousnessLevel.UNCONSCIOUS) {\n      recoveryModifier = 0.2; // Very slow recovery when unconscious\n    }\n\n    const recovery = this.baseRecoveryRate * deltaSeconds * recoveryModifier;\n    const newConsciousness = Math.min(100, player.consciousness + recovery);\n\n    return {\n      ...player,\n      consciousness: newConsciousness,\n    };\n  }\n\n  /**\n   * Determines consciousness level from consciousness value.\n   *\n   * Updated thresholds:\n   * - 90-100: Combat Alert\n   * - 50-89: Disoriented\n   * - 20-49: Stunned\n   * - 0-19: Unconscious (incapacitation threshold <20%)\n   *\n   * @param consciousness - Consciousness value (0-100)\n   * @returns Current consciousness level\n   *\n   * @example\n   * ```typescript\n   * const level = system.getLevel(75);\n   * console.log(level); // DISORIENTED\n   *\n   * const level2 = system.getLevel(15);\n   * console.log(level2); // UNCONSCIOUS (below incapacitation threshold)\n   * ```\n   *\n   * @public\n   * @korean 의식수준확인\n   */\n  getLevel(consciousness: number): ConsciousnessLevel {\n    if (consciousness >= 90) return ConsciousnessLevel.COMBAT_ALERT;\n    if (consciousness >= 50) return ConsciousnessLevel.DISORIENTED;\n    if (consciousness >= 20) return ConsciousnessLevel.STUNNED;\n    return ConsciousnessLevel.UNCONSCIOUS;\n  }\n\n  /**\n   * Gets effects for a specific consciousness level.\n   *\n   * @param level - Consciousness level\n   * @returns Effects applied at that level\n   *\n   * @public\n   * @korean 의식효과\n   */\n  getEffects(level: ConsciousnessLevel): ConsciousnessEffects {\n    return this.levelEffects[level];\n  }\n\n  /**\n   * Applies consciousness effects to player state.\n   *\n   * Modifies player stats based on current consciousness level.\n   *\n   * @param player - Current player state\n   * @returns Modified player state with consciousness effects\n   *\n   * @public\n   * @korean 의식효과적용\n   */\n  applyEffects(player: PlayerState): PlayerState {\n    const level = this.getLevel(player.consciousness);\n    const effects = this.getEffects(level);\n\n    return {\n      ...player,\n      attackPower: Math.floor(\n        player.attackPower * (1 - effects.accuracyPenalty)\n      ),\n      defense: Math.floor(player.defense * (1 - effects.defensePenalty)),\n      technique: Math.floor(player.technique * (1 - effects.accuracyPenalty)),\n      isStunned:\n        player.isStunned ||\n        level === ConsciousnessLevel.UNCONSCIOUS ||\n        level === ConsciousnessLevel.STUNNED,\n    };\n  }\n\n  /**\n   * Checks if player is at incapacitation threshold.\n   *\n   * **Korean**: 무력화한계 (Incapacitation Threshold)\n   *\n   * When consciousness drops below 20%, player becomes helpless for 3-5 seconds.\n   *\n   * @param player - Current player state\n   * @returns True if consciousness is below incapacitation threshold (<20%)\n   *\n   * @example\n   * ```typescript\n   * if (system.isAtIncapacitationThreshold(player)) {\n   *   // Player is helpless, trigger helpless state\n   *   const helplessDuration = system.getHelplessDuration();\n   *   console.log(`Player helpless for ${helplessDuration}ms`);\n   * }\n   * ```\n   *\n   * @public\n   * @korean 무력화한계확인\n   */\n  isAtIncapacitationThreshold(player: PlayerState): boolean {\n    return player.consciousness < this.incapacitationThreshold;\n  }\n\n  /**\n   * Gets random helpless duration when consciousness drops below threshold.\n   *\n   * Returns a random duration between 3-5 seconds (3000-5000ms).\n   *\n   * @returns Helpless duration in milliseconds\n   *\n   * @public\n   * @korean 무력화지속시간\n   */\n  getHelplessDuration(): number {\n    return (\n      this.helplessDuration.min +\n      Math.random() * (this.helplessDuration.max - this.helplessDuration.min)\n    );\n  }\n\n  /**\n   * Checks if enough time has passed for consciousness recovery.\n   *\n   * Consciousness only recovers after 5 seconds without head trauma.\n   *\n   * @param lastHeadTraumaTime - Timestamp of last head trauma\n   * @returns True if recovery is allowed\n   *\n   * @public\n   * @korean 회복가능확인\n   */\n  canRecover(lastHeadTraumaTime: number): boolean {\n    const timeSinceTrauma = Date.now() - lastHeadTraumaTime;\n    return timeSinceTrauma >= this.noTraumaRecoveryTime;\n  }\n\n  /**\n   * Checks if player is incapacitated due to consciousness.\n   *\n   * @param player - Current player state\n   * @returns True if player is unconscious\n   *\n   * @public\n   * @korean 무의식확인\n   */\n  isIncapacitated(player: PlayerState): boolean {\n    return (\n      this.getLevel(player.consciousness) === ConsciousnessLevel.UNCONSCIOUS\n    );\n  }\n\n  /**\n   * Gets bilingual name for consciousness level.\n   *\n   * @param level - Consciousness level\n   * @returns Korean and English level names\n   *\n   * @public\n   * @korean 의식이름\n   */\n  getLevelName(level: ConsciousnessLevel): { korean: string; english: string } {\n    const names: Record<\n      ConsciousnessLevel,\n      { korean: string; english: string }\n    > = {\n      [ConsciousnessLevel.COMBAT_ALERT]: {\n        korean: \"전투각성\",\n        english: \"Combat Alert\",\n      },\n      [ConsciousnessLevel.DISORIENTED]: {\n        korean: \"혼란상태\",\n        english: \"Disoriented\",\n      },\n      [ConsciousnessLevel.STUNNED]: {\n        korean: \"기절직전\",\n        english: \"Stunned\",\n      },\n      [ConsciousnessLevel.UNCONSCIOUS]: {\n        korean: \"무의식\",\n        english: \"Unconscious\",\n      },\n    };\n\n    return names[level];\n  }\n\n  /**\n   * Gets description of consciousness level effects.\n   *\n   * @param level - Consciousness level\n   * @returns Bilingual description\n   *\n   * @public\n   * @korean 의식설명\n   */\n  getLevelDescription(level: ConsciousnessLevel): {\n    korean: string;\n    english: string;\n  } {\n    const descriptions: Record<\n      ConsciousnessLevel,\n      { korean: string; english: string }\n    > = {\n      [ConsciousnessLevel.COMBAT_ALERT]: {\n        korean: \"완전한 의식과 전투 능력\",\n        english: \"Full awareness and combat ability\",\n      },\n      [ConsciousnessLevel.DISORIENTED]: {\n        korean: \"반응 시간 저하 및 혼란\",\n        english: \"Reduced reaction time and confusion\",\n      },\n      [ConsciousnessLevel.STUNNED]: {\n        korean: \"심각한 손상, 무력화 위험\",\n        english: \"Severe impairment, incapacitation risk\",\n      },\n      [ConsciousnessLevel.UNCONSCIOUS]: {\n        korean: \"완전한 무의식 상태\",\n        english: \"Complete unconsciousness\",\n      },\n    };\n\n    return descriptions[level];\n  }\n\n  /**\n   * Gets color indicator for consciousness level (for UI).\n   *\n   * @param level - Consciousness level\n   * @returns Hex color code\n   *\n   * @public\n   * @korean 의식색상\n   */\n  getLevelColor(level: ConsciousnessLevel): number {\n    const colors: Record<ConsciousnessLevel, number> = {\n      [ConsciousnessLevel.COMBAT_ALERT]: 0x00ff00, // Green\n      [ConsciousnessLevel.DISORIENTED]: 0xffaa00, // Orange\n      [ConsciousnessLevel.STUNNED]: 0xff4400, // Red-orange\n      [ConsciousnessLevel.UNCONSCIOUS]: 0xff0000, // Red\n    };\n\n    return colors[level];\n  }\n\n  /**\n   * Checks if consciousness is low enough to trigger fall animation.\n   *\n   * Falls occur when consciousness drops below 10% (UNCONSCIOUS threshold).\n   * This represents complete loss of ability to maintain standing position.\n   *\n   * Korean terminology:\n   * - 의식상실낙법 (Uisik Sangsil Nakbeop): Consciousness loss fall\n   * - 기절낙하 (Gijeol Nakha): Knockout collapse\n   *\n   * @param player - Current player state\n   * @returns True if fall animation should trigger\n   *\n   * @example\n   * ```typescript\n   * if (consciousnessSystem.shouldTriggerFall(player)) {\n   *   const fallType = consciousnessSystem.determineFallType(\n   *     player,\n   *     lastImpactAngle\n   *   );\n   *   animationMachine.transitionTo(FALL_TYPE_TO_ANIMATION[fallType]);\n   * }\n   * ```\n   *\n   * @public\n   * @korean 의식상실낙법확인\n   */\n  shouldTriggerFall(player: PlayerState): boolean {\n    return player.consciousness < 10; // UNCONSCIOUS threshold\n  }\n\n  /**\n   * Determines fall direction based on last impact and stance.\n   *\n   * When consciousness is lost, fall direction is determined by:\n   * - Last attack angle (if available)\n   * - Current stance bias (if no attack data)\n   * - Default to backward fall (natural collapse)\n   *\n   * Korean falling from consciousness loss:\n   * - 후방의식상실 (Hubang Uisik Sangsil): Backward consciousness loss fall\n   * - 전방기절 (Jeonbang Gijeol): Forward knockout\n   *\n   * @param player - Current player state\n   * @param lastImpactAngle - Angle of last hit (optional)\n   * @returns Fall type to use for animation\n   *\n   * @example\n   * ```typescript\n   * // Player loses consciousness from frontal head strike\n   * const fallType = consciousnessSystem.determineFallType(\n   *   player,\n   *   0 // Front angle\n   * );\n   * // Returns: 'backward' (knocked back by frontal strike)\n   *\n   * // Player loses consciousness without specific impact\n   * const fallType = consciousnessSystem.determineFallType(player);\n   * // Returns: Stance-based fall or 'backward' default\n   * ```\n   *\n   * @public\n   * @korean 의식상실낙법결정\n   */\n  determineFallType(_player: PlayerState, lastImpactAngle?: number): FallType {\n    // If we have impact angle, use simple direction logic\n    if (lastImpactAngle !== undefined) {\n      const normalizedAngle = Math.abs(lastImpactAngle);\n\n      // Front impact (0° ±45°) causes backward fall\n      if (normalizedAngle < Math.PI / 4) {\n        return \"backward\";\n      }\n\n      // Rear impact (180° ±45°) causes forward fall\n      // Since normalizedAngle is in [0, π], any angle > 3π/4 is a rear impact\n      if (normalizedAngle > (3 * Math.PI) / 4) {\n        return \"forward\";\n      }\n\n      // Side impacts: at this point normalizedAngle is in (π/4, 3π/4),\n      // so lastImpactAngle cannot be 0 or ±π.\n      if (lastImpactAngle < 0) {\n        return \"side_left\";\n      }\n      if (lastImpactAngle > 0) {\n        return \"side_right\";\n      }\n\n      // Fallback for exact 0 (or extremely small) angles in case future\n      // changes alter the front/rear checks above. We treat this as a\n      // natural backward collapse rather than a side fall.\n      return \"backward\";\n    }\n\n    // Default to backward fall (natural collapse from consciousness loss)\n    return \"backward\";\n  }\n\n  /**\n   * Determines fall type based on stance when consciousness is lost.\n   *\n   * Uses stance bias to determine fall direction when consciousness\n   * is lost without specific impact data.\n   *\n   * Korean terminology:\n   * - 자세의식상실 (Jase Uisik Sangsil): Stance-based consciousness loss\n   *\n   * @param stance - Current trigram stance\n   * @returns Fall type based on stance characteristics\n   *\n   * @example\n   * ```typescript\n   * // Player in Mountain stance (defensive back)\n   * const fallType = consciousnessSystem.determineFallTypeFromStance(\n   *   TrigramStance.GAN\n   * );\n   * // Returns: 'backward' (Mountain has defensive backward bias)\n   * ```\n   *\n   * @public\n   * @korean 자세의식상실낙법\n   */\n  determineFallTypeFromStance(stance: TrigramStance): FallType {\n    return determineFallFromStance(stance, \"backward\");\n  }\n}\n\nexport default ConsciousnessSystem;\n"],"mappings":"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"}

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

@@ -0,0 +1,82 @@
+/**
+ * Fall Integration Utilities
+ *
+ * Helper functions to check for fall conditions and determine fall animations
+ * based on balance and consciousness systems.
+ *
+ * @module systems/combat/FallIntegration
+ * @category Combat System
+ * @korean 낙법통합
+ */
+import type { AnimationState, FallType } from "../animation/core/types";
+import type { CombatSystem } from "../CombatSystem";
+import type { PlayerState } from "../player";
+/**
+ * Result of fall check with animation state
+ * @korean 낙법확인결과
+ */
+export interface FallCheckResult {
+    /** Whether a fall should be triggered */
+    readonly shouldFall: boolean;
+    /** Fall type if falling */
+    readonly fallType?: FallType;
+    /** Animation state to transition to */
+    readonly animationState?: AnimationState;
+    /** Reason for fall */
+    readonly reason?: "balance" | "consciousness";
+}
+/**
+ * Checks if player should fall and determines fall animation.
+ *
+ * Integrates BalanceSystem and ConsciousnessSystem to check fall conditions.
+ * Returns animation state to transition to if fall is triggered.
+ *
+ * Korean terminology:
+ * - 균형상실 (Gyunhyeong Sangsil): Balance loss
+ * - 의식상실 (Uisik Sangsil): Consciousness loss
+ *
+ * @param player - Player state to check
+ * @param combatSystem - Combat system with balance and consciousness systems
+ * @param lastImpactAngle - Optional angle of last impact (for consciousness falls)
+ * @param attackAngle - Optional angle of current attack (for balance falls)
+ * @returns Fall check result with animation state
+ *
+ * @example
+ * ```typescript
+ * const fallCheck = checkForFall(player, combatSystem, undefined, attackAngle);
+ * if (fallCheck.shouldFall && fallCheck.animationState) {
+ *   animationMachine.transitionTo(fallCheck.animationState);
+ *   console.log(`Player falling: ${fallCheck.reason}`);
+ * }
+ * ```
+ *
+ * @public
+ * @korean 낙법확인
+ */
+export declare function checkForFall(player: PlayerState, combatSystem: CombatSystem, lastImpactAngle?: number, attackAngle?: number): FallCheckResult;
+/**
+ * Checks if player is currently in a fall or ground animation state.
+ *
+ * Used to prevent other actions during falls and ground states.
+ *
+ * @param animationState - Current animation state
+ * @returns True if player is falling or on ground
+ *
+ * @public
+ * @korean 낙법중확인
+ */
+export declare function isInFallOrGroundState(animationState: AnimationState): boolean;
+/**
+ * Gets Korean description for fall type.
+ *
+ * @param fallType - Type of fall
+ * @returns Korean and English names
+ *
+ * @public
+ * @korean 낙법이름
+ */
+export declare function getFallTypeName(fallType: FallType): {
+    korean: string;
+    english: string;
+};
+//# sourceMappingURL=FallIntegration.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"FallIntegration.d.ts","sourceRoot":"","sources":["../../../src/systems/combat/FallIntegration.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAMxE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AACpD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAE7C;;;GAGG;AACH,MAAM,WAAW,eAAe;IAC9B,yCAAyC;IACzC,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;IAC7B,2BAA2B;IAC3B,QAAQ,CAAC,QAAQ,CAAC,EAAE,QAAQ,CAAC;IAC7B,uCAAuC;IACvC,QAAQ,CAAC,cAAc,CAAC,EAAE,cAAc,CAAC;IACzC,sBAAsB;IACtB,QAAQ,CAAC,MAAM,CAAC,EAAE,SAAS,GAAG,eAAe,CAAC;CAC/C;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,YAAY,CAC1B,MAAM,EAAE,WAAW,EACnB,YAAY,EAAE,YAAY,EAC1B,eAAe,CAAC,EAAE,MAAM,EACxB,WAAW,CAAC,EAAE,MAAM,GACnB,eAAe,CAsCjB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,qBAAqB,CAAC,cAAc,EAAE,cAAc,GAAG,OAAO,CAE7E;AAED;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,QAAQ,GAAG;IACnD,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;CACjB,CASA"}