blacktrigram 0.7.2

package/lib/systems/bodypart/PlayerInjuryTrackingManager.js

@@ -0,0 +1,175 @@
+import { InjuryTracker } from "./InjuryTracker.js";
+import { CombatInjuryIntegration } from "./CombatInjuryIntegration.js";
+//#region src/systems/bodypart/PlayerInjuryTrackingManager.ts
+/**
+* Player Injury Tracking Manager
+* 
+* **Korean**: 플레이어 부상 추적 관리자
+* 
+* Manages per-player injury tracking to prevent mixing injuries between
+* multiple characters in combat scenarios. Each player gets their own
+* InjuryTracker instance.
+* 
+* @module systems/bodypart
+* @category Injury Tracking
+* @korean 부상추적
+*/
+/**
+* Manager for per-player injury tracking.
+* 
+* **Korean**: 플레이어별 부상 추적 관리자
+* 
+* Maintains separate {@link InjuryTracker} and {@link CombatInjuryIntegration}
+* instances for each player to ensure injuries don't get mixed between characters.
+* 
+* @example
+* ```typescript
+* const manager = new PlayerInjuryTrackingManager();
+* 
+* // Get or create tracker for a player
+* const player1Tracker = manager.getTrackerForPlayer('player-1');
+* const player1Integration = manager.getIntegrationForPlayer('player-1');
+* 
+* // Record injury for specific player
+* player1Integration.recordCombatDamage({
+*   damage: 35,
+*   bodyRegion: BodyRegion.TORSO,
+*   damageType: DamageType.BLUNT,
+* });
+* 
+* // Clear injuries for a player (e.g., between rounds)
+* manager.clearPlayerInjuries('player-1');
+* ```
+* 
+* @public
+*/
+var PlayerInjuryTrackingManager = class {
+	trackers = /* @__PURE__ */ new Map();
+	integrations = /* @__PURE__ */ new Map();
+	/**
+	* Get the InjuryTracker for a specific player, creating it if needed.
+	* 
+	* **Korean**: 특정 플레이어의 InjuryTracker 가져오기 (필요시 생성)
+	* 
+	* @param playerId - Unique player identifier (string or number)
+	* @returns InjuryTracker instance for the player
+	* 
+	* @public
+	*/
+	getTrackerForPlayer(playerId) {
+		const key = String(playerId);
+		let tracker = this.trackers.get(key);
+		if (!tracker) {
+			tracker = new InjuryTracker();
+			this.trackers.set(key, tracker);
+		}
+		return tracker;
+	}
+	/**
+	* Get the CombatInjuryIntegration for a specific player, creating it if needed.
+	* 
+	* **Korean**: 특정 플레이어의 CombatInjuryIntegration 가져오기 (필요시 생성)
+	* 
+	* @param playerId - Unique player identifier (string or number)
+	* @returns CombatInjuryIntegration instance for the player
+	* 
+	* @public
+	*/
+	getIntegrationForPlayer(playerId) {
+		const key = String(playerId);
+		let integration = this.integrations.get(key);
+		if (!integration) {
+			integration = new CombatInjuryIntegration({
+				enabled: true,
+				minDamage: 5,
+				bloodThreshold: 30,
+				tracker: this.getTrackerForPlayer(playerId)
+			});
+			this.integrations.set(key, integration);
+		}
+		return integration;
+	}
+	/**
+	* Clear all injuries for a specific player.
+	* 
+	* **Korean**: 특정 플레이어의 모든 부상 제거
+	* 
+	* Useful for round resets or when a player is defeated.
+	* 
+	* @param playerId - Unique player identifier (string or number)
+	* 
+	* @public
+	*/
+	clearPlayerInjuries(playerId) {
+		const key = String(playerId);
+		const tracker = this.trackers.get(key);
+		if (tracker) tracker.clearInjuries();
+	}
+	/**
+	* Remove tracking data for a player (e.g., when they leave the game).
+	* 
+	* **Korean**: 플레이어 추적 데이터 제거
+	* 
+	* @param playerId - Unique player identifier (string or number)
+	* 
+	* @public
+	*/
+	removePlayer(playerId) {
+		const key = String(playerId);
+		this.trackers.delete(key);
+		this.integrations.delete(key);
+	}
+	/**
+	* Clear all player tracking data.
+	* 
+	* **Korean**: 모든 플레이어 추적 데이터 제거
+	* 
+	* Useful for resetting the entire game state.
+	* 
+	* @public
+	*/
+	clearAll() {
+		this.trackers.clear();
+		this.integrations.clear();
+	}
+	/**
+	* Get all active player IDs being tracked.
+	* 
+	* **Korean**: 추적 중인 모든 플레이어 ID 가져오기
+	* 
+	* @returns Array of player IDs
+	* 
+	* @public
+	*/
+	getActivePlayerIds() {
+		return Array.from(this.trackers.keys());
+	}
+};
+/**
+* Global singleton manager for player injury tracking.
+* 
+* **Korean**: 플레이어 부상 추적을 위한 전역 싱글톤 관리자
+* 
+* This singleton manages per-player injury trackers to ensure injuries
+* from different characters don't get mixed together.
+* 
+* @example
+* ```typescript
+* import { playerInjuryManager } from '@/systems/bodypart';
+* 
+* // In combat code:
+* const defenderIntegration = playerInjuryManager.getIntegrationForPlayer(defender.id);
+* defenderIntegration.recordCombatDamage({
+*   damage: result.damage,
+*   bodyRegion,
+*   damageType,
+* });
+* ```
+* 
+* @public
+*/
+var playerInjuryManager = new PlayerInjuryTrackingManager();
+//#endregion
+export { PlayerInjuryTrackingManager, playerInjuryManager };
+
+//# sourceMappingURL=PlayerInjuryTrackingManager.js.map

package/lib/systems/bodypart/PlayerInjuryTrackingManager.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PlayerInjuryTrackingManager.js","names":[],"sources":["../../../src/systems/bodypart/PlayerInjuryTrackingManager.ts"],"sourcesContent":["/**\n * Player Injury Tracking Manager\n * \n * **Korean**: 플레이어 부상 추적 관리자\n * \n * Manages per-player injury tracking to prevent mixing injuries between\n * multiple characters in combat scenarios. Each player gets their own\n * InjuryTracker instance.\n * \n * @module systems/bodypart\n * @category Injury Tracking\n * @korean 부상추적\n */\n\nimport { InjuryTracker } from \"./InjuryTracker\";\nimport { CombatInjuryIntegration } from \"./CombatInjuryIntegration\";\n\n/**\n * Manager for per-player injury tracking.\n * \n * **Korean**: 플레이어별 부상 추적 관리자\n * \n * Maintains separate {@link InjuryTracker} and {@link CombatInjuryIntegration}\n * instances for each player to ensure injuries don't get mixed between characters.\n * \n * @example\n * ```typescript\n * const manager = new PlayerInjuryTrackingManager();\n * \n * // Get or create tracker for a player\n * const player1Tracker = manager.getTrackerForPlayer('player-1');\n * const player1Integration = manager.getIntegrationForPlayer('player-1');\n * \n * // Record injury for specific player\n * player1Integration.recordCombatDamage({\n *   damage: 35,\n *   bodyRegion: BodyRegion.TORSO,\n *   damageType: DamageType.BLUNT,\n * });\n * \n * // Clear injuries for a player (e.g., between rounds)\n * manager.clearPlayerInjuries('player-1');\n * ```\n * \n * @public\n */\nexport class PlayerInjuryTrackingManager {\n  private trackers = new Map<string, InjuryTracker>();\n  private integrations = new Map<string, CombatInjuryIntegration>();\n\n  /**\n   * Get the InjuryTracker for a specific player, creating it if needed.\n   * \n   * **Korean**: 특정 플레이어의 InjuryTracker 가져오기 (필요시 생성)\n   * \n   * @param playerId - Unique player identifier (string or number)\n   * @returns InjuryTracker instance for the player\n   * \n   * @public\n   */\n  getTrackerForPlayer(playerId: string | number): InjuryTracker {\n    const key = String(playerId);\n    let tracker = this.trackers.get(key);\n    if (!tracker) {\n      tracker = new InjuryTracker();\n      this.trackers.set(key, tracker);\n    }\n    return tracker;\n  }\n\n  /**\n   * Get the CombatInjuryIntegration for a specific player, creating it if needed.\n   * \n   * **Korean**: 특정 플레이어의 CombatInjuryIntegration 가져오기 (필요시 생성)\n   * \n   * @param playerId - Unique player identifier (string or number)\n   * @returns CombatInjuryIntegration instance for the player\n   * \n   * @public\n   */\n  getIntegrationForPlayer(playerId: string | number): CombatInjuryIntegration {\n    const key = String(playerId);\n    let integration = this.integrations.get(key);\n    if (!integration) {\n      const tracker = this.getTrackerForPlayer(playerId);\n      // Pass complete config with tracker override\n      integration = new CombatInjuryIntegration({\n        enabled: true,\n        minDamage: 5,\n        bloodThreshold: 30,\n        tracker,\n      });\n      this.integrations.set(key, integration);\n    }\n    return integration;\n  }\n\n  /**\n   * Clear all injuries for a specific player.\n   * \n   * **Korean**: 특정 플레이어의 모든 부상 제거\n   * \n   * Useful for round resets or when a player is defeated.\n   * \n   * @param playerId - Unique player identifier (string or number)\n   * \n   * @public\n   */\n  clearPlayerInjuries(playerId: string | number): void {\n    const key = String(playerId);\n    const tracker = this.trackers.get(key);\n    if (tracker) {\n      tracker.clearInjuries();\n    }\n  }\n\n  /**\n   * Remove tracking data for a player (e.g., when they leave the game).\n   * \n   * **Korean**: 플레이어 추적 데이터 제거\n   * \n   * @param playerId - Unique player identifier (string or number)\n   * \n   * @public\n   */\n  removePlayer(playerId: string | number): void {\n    const key = String(playerId);\n    this.trackers.delete(key);\n    this.integrations.delete(key);\n  }\n\n  /**\n   * Clear all player tracking data.\n   * \n   * **Korean**: 모든 플레이어 추적 데이터 제거\n   * \n   * Useful for resetting the entire game state.\n   * \n   * @public\n   */\n  clearAll(): void {\n    this.trackers.clear();\n    this.integrations.clear();\n  }\n\n  /**\n   * Get all active player IDs being tracked.\n   * \n   * **Korean**: 추적 중인 모든 플레이어 ID 가져오기\n   * \n   * @returns Array of player IDs\n   * \n   * @public\n   */\n  getActivePlayerIds(): string[] {\n    return Array.from(this.trackers.keys());\n  }\n}\n\n/**\n * Global singleton manager for player injury tracking.\n * \n * **Korean**: 플레이어 부상 추적을 위한 전역 싱글톤 관리자\n * \n * This singleton manages per-player injury trackers to ensure injuries\n * from different characters don't get mixed together.\n * \n * @example\n * ```typescript\n * import { playerInjuryManager } from '@/systems/bodypart';\n * \n * // In combat code:\n * const defenderIntegration = playerInjuryManager.getIntegrationForPlayer(defender.id);\n * defenderIntegration.recordCombatDamage({\n *   damage: result.damage,\n *   bodyRegion,\n *   damageType,\n * });\n * ```\n * \n * @public\n */\nexport const playerInjuryManager = new PlayerInjuryTrackingManager();\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8CA,IAAa,8BAAb,MAAyC;CACvC,2BAAmB,IAAI,KAA4B;CACnD,+BAAuB,IAAI,KAAsC;;;;;;;;;;;CAYjE,oBAAoB,UAA0C;EAC5D,MAAM,MAAM,OAAO,SAAS;EAC5B,IAAI,UAAU,KAAK,SAAS,IAAI,IAAI;AACpC,MAAI,CAAC,SAAS;AACZ,aAAU,IAAI,eAAe;AAC7B,QAAK,SAAS,IAAI,KAAK,QAAQ;;AAEjC,SAAO;;;;;;;;;;;;CAaT,wBAAwB,UAAoD;EAC1E,MAAM,MAAM,OAAO,SAAS;EAC5B,IAAI,cAAc,KAAK,aAAa,IAAI,IAAI;AAC5C,MAAI,CAAC,aAAa;AAGhB,iBAAc,IAAI,wBAAwB;IACxC,SAAS;IACT,WAAW;IACX,gBAAgB;IAChB,SANc,KAAK,oBAAoB,SAAS;IAOjD,CAAC;AACF,QAAK,aAAa,IAAI,KAAK,YAAY;;AAEzC,SAAO;;;;;;;;;;;;;CAcT,oBAAoB,UAAiC;EACnD,MAAM,MAAM,OAAO,SAAS;EAC5B,MAAM,UAAU,KAAK,SAAS,IAAI,IAAI;AACtC,MAAI,QACF,SAAQ,eAAe;;;;;;;;;;;CAa3B,aAAa,UAAiC;EAC5C,MAAM,MAAM,OAAO,SAAS;AAC5B,OAAK,SAAS,OAAO,IAAI;AACzB,OAAK,aAAa,OAAO,IAAI;;;;;;;;;;;CAY/B,WAAiB;AACf,OAAK,SAAS,OAAO;AACrB,OAAK,aAAa,OAAO;;;;;;;;;;;CAY3B,qBAA+B;AAC7B,SAAO,MAAM,KAAK,KAAK,SAAS,MAAM,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;AA2B3C,IAAa,sBAAsB,IAAI,6BAA6B"}

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

@@ -0,0 +1,22 @@
+/**
+ * Body Part Health System Module
+ *
+ * **Korean**: 신체부위 체력 시스템 모듈
+ *
+ * Provides body part-specific health tracking, damage distribution, and
+ * combat capability effects for realistic localized damage mechanics.
+ *
+ * @module systems/bodypart
+ * @category Body Part System
+ * @korean 신체부위시스템
+ */
+export * from "./types";
+export * from "./BodyPartHealthSystem";
+export * from "./BodyPartDamageIntegration";
+export * from "./MovementPenaltySystem";
+export * from "./InjuryTracker";
+export * from "./BodyPartPositionMapping";
+export * from "./InjuryIntegration";
+export * from "./CombatInjuryIntegration";
+export * from "./PlayerInjuryTrackingManager";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/systems/bodypart/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,cAAc,SAAS,CAAC;AACxB,cAAc,wBAAwB,CAAC;AACvC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,yBAAyB,CAAC;AACxC,cAAc,iBAAiB,CAAC;AAChC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,qBAAqB,CAAC;AACpC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,+BAA+B,CAAC"}

package/lib/systems/bodypart/index.js

@@ -0,0 +1,8 @@
+import "./types.js";
+import "./BodyPartHealthSystem.js";
+import "./BodyPartDamageIntegration.js";
+import "./MovementPenaltySystem.js";
+import "./InjuryTracker.js";
+import "./BodyPartPositionMapping.js";
+import "./CombatInjuryIntegration.js";
+import "./PlayerInjuryTrackingManager.js";

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

@@ -0,0 +1,453 @@
+/**
+ * Body Part Health System Types
+ *
+ * **Korean**: 신체부위 체력 시스템 타입
+ *
+ * This module defines types for the body part-specific health tracking system,
+ * which replaces the single health bar with independent health tracking for
+ * each major body region. This enables realistic localized damage and combat
+ * trauma simulation.
+ *
+ * ## Body Part Health Philosophy
+ *
+ * Traditional Korean martial arts emphasize targeting specific body regions
+ * to achieve maximum combat effectiveness. This system reflects that by
+ * tracking damage to:
+ * - **HEAD** (두부): Consciousness and awareness
+ * - **NECK** (경부): Vascular and respiratory function
+ * - **TORSO_UPPER** (상부 몸통): Heart, lungs, vital organs
+ * - **TORSO_LOWER** (하부 몸통): Stamina and core strength
+ * - **ARM_LEFT/RIGHT** (좌/우팔): Attack capability
+ * - **LEG_LEFT/RIGHT** (좌/우다리): Mobility and balance
+ *
+ * @module systems/bodypart/types
+ * @category Body Part System
+ * @korean 신체부위타입
+ */
+import { KoreanText } from "../../types";
+/**
+ * Body part identifiers for health tracking.
+ *
+ * **Korean**: 신체 부위 (Body Parts)
+ *
+ * Each body part tracks independent health from 0-100 HP. Damage to specific
+ * parts affects different combat capabilities based on anatomical function.
+ *
+ * @example
+ * ```typescript
+ * const bodyPart: BodyPart = BodyPart.HEAD;
+ * const health = player.bodyPartHealth[bodyPart]; // 0-100
+ * ```
+ *
+ * @public
+ * @category Body Part System
+ * @korean 신체부위
+ */
+export declare enum BodyPart {
+    /** Head region - affects consciousness and awareness */
+    HEAD = "head",
+    /** Neck region - affects breathing and blood flow */
+    NECK = "neck",
+    /** Upper torso - affects heart, lungs, stamina recovery */
+    TORSO_UPPER = "torsoUpper",
+    /** Lower torso - affects core strength and balance */
+    TORSO_LOWER = "torsoLower",
+    /** Left arm - affects attack capability on left side */
+    ARM_LEFT = "armLeft",
+    /** Right arm - affects attack capability on right side */
+    ARM_RIGHT = "armRight",
+    /** Left leg - affects movement and balance */
+    LEG_LEFT = "legLeft",
+    /** Right leg - affects movement and balance */
+    LEG_RIGHT = "legRight"
+}
+/**
+ * Health values for each body part (0-100 HP per part).
+ *
+ * **Korean**: 신체 부위별 체력
+ *
+ * Tracks independent health pools for each major body region. When a body part
+ * reaches 0 HP, it becomes non-functional and applies severe combat penalties.
+ *
+ * ## Default Health Values
+ *
+ * All body parts start at 100 HP. Different archetypes may have variations:
+ * - **무사 (Musa)**: Balanced health across all parts
+ * - **암살자 (Amsalja)**: Lower torso health, higher arm precision
+ * - **해커 (Hacker)**: Enhanced head/neck (cyber augmentation)
+ * - **정보요원 (Jeongbo)**: Balanced with slight defensive boost
+ * - **조직폭력배 (Jojik)**: Higher torso/leg health (street hardened)
+ *
+ * @example
+ * ```typescript
+ * const bodyHealth: BodyPartHealth = {
+ *   head: 100,
+ *   neck: 100,
+ *   torsoUpper: 100,
+ *   torsoLower: 100,
+ *   armLeft: 100,
+ *   armRight: 100,
+ *   legLeft: 100,
+ *   legRight: 100,
+ * };
+ * ```
+ *
+ * @public
+ * @category Body Part System
+ * @korean 신체부위체력
+ */
+export interface BodyPartHealth {
+    /** Head health (0-100 HP) - affects consciousness */
+    readonly head: number;
+    /** Neck health (0-100 HP) - affects breathing and circulation */
+    readonly neck: number;
+    /** Upper torso health (0-100 HP) - affects stamina recovery */
+    readonly torsoUpper: number;
+    /** Lower torso health (0-100 HP) - affects balance and core strength */
+    readonly torsoLower: number;
+    /** Left arm health (0-100 HP) - affects left-side attacks */
+    readonly armLeft: number;
+    /** Right arm health (0-100 HP) - affects right-side attacks */
+    readonly armRight: number;
+    /** Left leg health (0-100 HP) - affects movement and stance */
+    readonly legLeft: number;
+    /** Right leg health (0-100 HP) - affects movement and stance */
+    readonly legRight: number;
+}
+/**
+ * Maximum health values for each body part.
+ *
+ * **Korean**: 최대 신체 부위 체력
+ *
+ * Defines the maximum HP capacity for each body part. Can be modified by
+ * archetype, equipment, or training bonuses.
+ *
+ * @public
+ * @category Body Part System
+ * @korean 최대신체부위체력
+ */
+export interface BodyPartMaxHealth {
+    /** Maximum head health */
+    readonly head: number;
+    /** Maximum neck health */
+    readonly neck: number;
+    /** Maximum upper torso health */
+    readonly torsoUpper: number;
+    /** Maximum lower torso health */
+    readonly torsoLower: number;
+    /** Maximum left arm health */
+    readonly armLeft: number;
+    /** Maximum right arm health */
+    readonly armRight: number;
+    /** Maximum left leg health */
+    readonly legLeft: number;
+    /** Maximum right leg health */
+    readonly legRight: number;
+}
+/**
+ * Combat capability effects from body part damage.
+ *
+ * **Korean**: 신체 부위 손상 효과
+ *
+ * Defines how damage to specific body parts affects combat performance.
+ * Effects are applied as multipliers to base stats (0.0 = disabled, 1.0 = normal).
+ *
+ * ## Effect Thresholds
+ *
+ * - **100-75% HP**: No penalties (1.0x)
+ * - **75-50% HP**: Minor penalties (0.9-0.8x)
+ * - **50-25% HP**: Major penalties (0.7-0.5x)
+ * - **25-0% HP**: Severe penalties (0.3-0.1x)
+ * - **0% HP**: Non-functional (0.0x)
+ *
+ * @example
+ * ```typescript
+ * const effects: BodyPartEffects = {
+ *   consciousnessModifier: 0.75, // Head at 50% HP
+ *   staminaRegenModifier: 0.5,   // Torso damaged
+ *   attackDamageModifier: 0.7,   // Arm injured
+ *   movementSpeedModifier: 0.6,  // Leg damaged
+ * };
+ * ```
+ *
+ * @public
+ * @category Body Part System
+ * @korean 신체부위효과
+ */
+export interface BodyPartEffects {
+    /** Consciousness and awareness multiplier (0.0-1.0) - from head/neck damage */
+    readonly consciousnessModifier: number;
+    /** Stamina regeneration multiplier (0.0-1.0) - from torso damage */
+    readonly staminaRegenModifier: number;
+    /** Attack damage multiplier (0.0-1.0) - from arm damage */
+    readonly attackDamageModifier: number;
+    /** Movement speed multiplier (0.0-1.0) - from leg damage */
+    readonly movementSpeedModifier: number;
+    /** Balance modifier (0.0-1.0) - from lower torso and leg damage */
+    readonly balanceModifier: number;
+    /** Technique accuracy multiplier (0.0-1.0) - from head/arm damage */
+    readonly techniqueAccuracyModifier: number;
+}
+/**
+ * Damage distribution configuration for body parts.
+ *
+ * **Korean**: 신체 부위 피해 분배
+ *
+ * Defines how damage from attacks is distributed across body parts based on
+ * the hit location and attack type. Not all damage goes to a single part;
+ * impact can affect adjacent regions.
+ *
+ * @example
+ * ```typescript
+ * // Strike to head distributes damage
+ * const distribution: BodyPartDamageDistribution = {
+ *   primary: { part: BodyPart.HEAD, percentage: 0.8 },
+ *   secondary: [
+ *     { part: BodyPart.NECK, percentage: 0.2 }
+ *   ]
+ * };
+ * ```
+ *
+ * @public
+ * @category Body Part System
+ * @korean 신체부위피해분배
+ */
+export interface BodyPartDamageDistribution {
+    /** Primary body part receiving most damage */
+    readonly primary: {
+        readonly part: BodyPart;
+        readonly percentage: number;
+    };
+    /** Secondary body parts receiving splash damage */
+    readonly secondary: readonly {
+        readonly part: BodyPart;
+        readonly percentage: number;
+    }[];
+}
+/**
+ * Body part status information for UI display.
+ *
+ * **Korean**: 신체 부위 상태 정보
+ *
+ * Provides UI-friendly data about body part health status including
+ * color coding, status text, and icon information.
+ *
+ * @public
+ * @category Body Part System
+ * @korean 신체부위상태
+ */
+export interface BodyPartStatus {
+    /** Body part identifier */
+    readonly part: BodyPart;
+    /** Current health (0-100) */
+    readonly health: number;
+    /** Maximum health */
+    readonly maxHealth: number;
+    /** Health percentage (0.0-1.0) */
+    readonly percentage: number;
+    /** Status description */
+    readonly status: KoreanText;
+    /** Color code for UI (hex number) */
+    readonly color: number;
+    /** Whether this part is critically damaged */
+    readonly critical: boolean;
+    /** Whether this part is non-functional */
+    readonly disabled: boolean;
+}
+/**
+ * Configuration for body part health system.
+ *
+ * **Korean**: 신체 부위 시스템 설정
+ *
+ * Defines thresholds, multipliers, and constants used by the body part
+ * health system for damage calculation and effect application.
+ *
+ * @public
+ * @category Body Part System
+ * @korean 신체부위설정
+ */
+export interface BodyPartHealthConfig {
+    /** Default max health for all body parts */
+    readonly defaultMaxHealth: number;
+    /** Health threshold for minor penalties (percentage) */
+    readonly minorPenaltyThreshold: number;
+    /** Health threshold for major penalties (percentage) */
+    readonly majorPenaltyThreshold: number;
+    /** Health threshold for severe penalties (percentage) */
+    readonly severePenaltyThreshold: number;
+    /** Health threshold for critical status (percentage) */
+    readonly criticalThreshold: number;
+    /** Effect multipliers for each threshold tier */
+    readonly effectMultipliers: {
+        readonly minor: number;
+        readonly major: number;
+        readonly severe: number;
+        readonly critical: number;
+    };
+}
+/**
+ * Default configuration values for body part health system.
+ *
+ * @public
+ * @category Body Part System
+ */
+export declare const DEFAULT_BODY_PART_CONFIG: BodyPartHealthConfig;
+/**
+ * Body part health effect constants matching acceptance criteria.
+ *
+ * **Korean**: 신체 부위 효과 상수
+ *
+ * Defines specific combat penalties as per requirements:
+ * - Head <50%: Consciousness penalties
+ * - Torso <50%: Stamina regen -50%
+ * - Arms <50%: Attack damage -30%
+ * - Legs <50%: Movement speed -40%
+ *
+ * @public
+ * @category Body Part System
+ */
+export declare const BODY_PART_EFFECT_CONSTANTS: {
+    /** Head damage effects */
+    readonly HEAD: {
+        readonly CONSCIOUSNESS_PENALTY_AT_50: 0.75;
+        readonly CRITICAL_THRESHOLD: 0.5;
+    };
+    /** Torso damage effects */
+    readonly TORSO: {
+        readonly STAMINA_REGEN_PENALTY_AT_50: 0.5;
+        readonly CRITICAL_THRESHOLD: 0.5;
+    };
+    /** Arm damage effects */
+    readonly ARMS: {
+        readonly ATTACK_DAMAGE_PENALTY_AT_50: 0.7;
+        readonly CRITICAL_THRESHOLD: 0.5;
+    };
+    /** Leg damage effects */
+    readonly LEGS: {
+        readonly MOVEMENT_SPEED_PENALTY_AT_50: 0.6;
+        readonly CRITICAL_THRESHOLD: 0.5;
+    };
+};
+/**
+ * Leg injury severity levels for movement penalties.
+ *
+ * **Korean**: 다리 부상 정도 (Leg Injury Severity)
+ *
+ * Defines movement impairment states based on leg health percentage.
+ *
+ * @public
+ * @category Body Part System
+ * @korean 다리부상정도
+ */
+export declare enum LegInjuryState {
+    /** Normal movement - Leg health 100-70% */
+    NORMAL = "normal",
+    /** Limping - Leg health 69-50% */
+    LIMPING = "limping",
+    /** Severe limp - Leg health 49-30% */
+    SEVERE_LIMP = "severe_limp",
+    /** Hobbled - Leg health <30%, cannot run */
+    HOBBLED = "hobbled"
+}
+/**
+ * Movement penalty applied from leg damage.
+ *
+ * **Korean**: 이동 패널티 (Movement Penalty)
+ *
+ * Describes the current movement impairment including speed reduction,
+ * stance change penalties, and balance effects.
+ *
+ * @public
+ * @category Body Part System
+ * @korean 이동패널티
+ */
+export interface MovementPenalty {
+    /** Movement speed multiplier (0.0-1.0) */
+    readonly speedMultiplier: number;
+    /** Whether player can run (false when hobbled) */
+    readonly canRun: boolean;
+    /** Current injury state */
+    readonly injuryState: LegInjuryState;
+    /** Stance change duration multiplier (1.0 = normal, 2.0 = 2x slower) */
+    readonly stanceChangePenalty: number;
+    /** Whether advanced stances are restricted */
+    readonly advancedStancesRestricted: boolean;
+    /** Balance modifier from leg damage (0.0-1.0) */
+    readonly balanceModifier: number;
+    /** Whether instant penalty is active (from knee/ankle strike) */
+    readonly hasInstantPenalty: boolean;
+    /** Timestamp when instant penalty expires (0 if not active) */
+    readonly instantPenaltyExpiry: number;
+}
+/**
+ * Instant movement penalty from knee/ankle strikes.
+ *
+ * **Korean**: 순간 이동 패널티 (Instant Movement Penalty)
+ *
+ * Applied immediately upon striking knee or ankle vital points,
+ * causing temporary severe movement impairment.
+ *
+ * @public
+ * @category Body Part System
+ * @korean 순간이동패널티
+ */
+export interface InstantMovementPenalty {
+    /** Speed multiplier during instant penalty */
+    readonly speedMultiplier: number;
+    /** Duration in milliseconds */
+    readonly duration: number;
+    /** Timestamp when penalty was applied */
+    readonly appliedAt: number;
+    /** Body part that was struck */
+    readonly affectedPart: BodyPart;
+}
+/**
+ * Movement penalty constants matching acceptance criteria.
+ *
+ * **Korean**: 이동 패널티 상수
+ *
+ * Defines thresholds and multipliers for injury-based movement penalties:
+ * - 100-70%: Normal speed (100%)
+ * - 69-50%: Limping (-20% speed)
+ * - 49-30%: Severe limp (-40% speed)
+ * - <30%: Hobbled (-60% speed, cannot run)
+ *
+ * @public
+ * @category Body Part System
+ */
+export declare const MOVEMENT_PENALTY_CONSTANTS: {
+    /** Health percentage thresholds for injury states */
+    readonly THRESHOLDS: {
+        readonly NORMAL: 0.7;
+        readonly LIMPING: 0.5;
+        readonly SEVERE_LIMP: 0.3;
+        readonly HOBBLED: 0;
+    };
+    /** Speed multipliers for each injury state */
+    readonly SPEED_MULTIPLIERS: {
+        readonly NORMAL: 1;
+        readonly LIMPING: 0.8;
+        readonly SEVERE_LIMP: 0.6;
+        readonly HOBBLED: 0.4;
+    };
+    /** Stance change penalty multipliers */
+    readonly STANCE_CHANGE: {
+        readonly NORMAL: 1;
+        readonly INJURED: 2;
+        readonly CRITICAL_THRESHOLD: 0.5;
+        readonly RESTRICTION_THRESHOLD: 0.3;
+    };
+    /** Instant penalty from knee/ankle strikes */
+    readonly INSTANT_PENALTY: {
+        readonly SPEED_MULTIPLIER: 0.3;
+        readonly DURATION: 5000;
+    };
+    /** Asymmetric damage effects */
+    readonly ASYMMETRIC: {
+        /** Penalty when moving toward injured side */
+        readonly SAME_SIDE_PENALTY: 0.8;
+        /** Penalty when moving away from injured side */
+        readonly OPPOSITE_SIDE_PENALTY: 0.9;
+    };
+};
+//# sourceMappingURL=types.d.ts.map

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

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