blacktrigram 0.7.2

package/lib/systems/combat/GrappleSystem.js

@@ -0,0 +1,393 @@
+import { CombatState, GrappleState, GrappleTarget, TrigramStance } from "../../types/common.js";
+import "../../types/index.js";
+import { asExtendedGonTechnique } from "../trigram/types/GonTechniqueExtensions.js";
+//#region src/systems/combat/GrappleSystem.ts
+/**
+* Default grappling configuration values.
+*/
+var DEFAULT_GRAPPLE_CONFIG = {
+	baseStaminaCostPerSecond: 5,
+	minGripStrength: 20,
+	maxGripStrength: 100,
+	baseEscapeDifficulty: 1.5,
+	escapeStaminaCost: 15,
+	minControlDuration: 500
+};
+/**
+* Grappling System for control and hold mechanics.
+*
+* **Korean**: 잡기 시스템 (Grapple System)
+*
+* Manages grappling state between combatants, including grip strength,
+* control duration, escape mechanics, and follow-up techniques.
+*/
+var GrappleSystem = class {
+	config;
+	constructor(config = {}) {
+		this.config = {
+			...DEFAULT_GRAPPLE_CONFIG,
+			...config
+		};
+	}
+	/**
+	* Attempt to initiate a grapple on target.
+	*
+	* **Korean**: 잡기 시도 (Attempt Grapple)
+	*
+	* @param attacker - Player attempting the grapple
+	* @param defender - Target player
+	* @param target - Body part to grapple
+	* @param currentTime - Current game time in milliseconds
+	* @returns Result of the grapple attempt
+	*/
+	attemptGrapple(attacker, defender, target, currentTime) {
+		if (attacker.combatState === CombatState.STUNNED) return {
+			success: false,
+			reason: "Attacker is stunned",
+			staminaCost: 0
+		};
+		if (attacker.combatState === CombatState.GRAPPLING) return {
+			success: false,
+			reason: "Attacker is already grappling another opponent",
+			staminaCost: 0
+		};
+		if (attacker.stamina < this.config.escapeStaminaCost) return {
+			success: false,
+			reason: "Insufficient stamina",
+			staminaCost: 0
+		};
+		if (defender.combatState === CombatState.GRAPPLED) return {
+			success: false,
+			reason: "Target is already being grappled",
+			staminaCost: 0
+		};
+		const gripStrength = this.calculateGripStrength(attacker, target);
+		const successChance = this.calculateGrappleSuccessChance(attacker, defender, target);
+		if (Math.random() < successChance) return {
+			success: true,
+			grappleControl: {
+				state: GrappleState.GRABBING,
+				target,
+				controllerId: attacker.id,
+				targetId: defender.id,
+				gripStrength,
+				duration: 0,
+				startTime: currentTime,
+				canEscape: false,
+				staminaCostPerSecond: this.calculateStaminaCost(target, gripStrength)
+			},
+			staminaCost: this.config.escapeStaminaCost
+		};
+		return {
+			success: false,
+			reason: `Grapple attempt failed (${Math.round(successChance * 100)}% chance)`,
+			staminaCost: this.config.escapeStaminaCost * .5
+		};
+	}
+	/**
+	* Update grapple control state over time.
+	*
+	* **Korean**: 잡기 업데이트 (Update Grapple)
+	*
+	* @param grappleControl - Current grapple control state
+	* @param controller - Player maintaining control
+	* @param target - Player being controlled
+	* @param deltaTime - Time elapsed since last update (seconds)
+	* @param currentTime - Current game time in milliseconds
+	* @returns Updated grapple control or null if broken
+	*/
+	updateGrapple(grappleControl, controller, _target, deltaTime, currentTime) {
+		if (controller.stamina < grappleControl.staminaCostPerSecond * deltaTime || controller.combatState === CombatState.STUNNED) return null;
+		const newDuration = currentTime - grappleControl.startTime;
+		let newState = grappleControl.state;
+		if (grappleControl.state === GrappleState.GRABBING && newDuration > 0) newState = GrappleState.CONTROLLING;
+		const rawGripStrength = grappleControl.gripStrength - 2 * deltaTime;
+		if (rawGripStrength < this.config.minGripStrength) return null;
+		const newGripStrength = rawGripStrength;
+		const canEscape = newDuration >= this.config.minControlDuration;
+		return {
+			...grappleControl,
+			state: newState,
+			gripStrength: newGripStrength,
+			duration: newDuration,
+			canEscape
+		};
+	}
+	/**
+	* Attempt to escape from a grapple.
+	*
+	* **Korean**: 탈출 시도 (Attempt Escape)
+	*
+	* @param grappleControl - Current grapple control state
+	* @param controller - Player maintaining control
+	* @param target - Player attempting to escape
+	* @returns Result of the escape attempt
+	*/
+	attemptEscape(grappleControl, controller, target) {
+		if (!grappleControl.canEscape) return {
+			success: false,
+			grappleControl,
+			reason: "Cannot escape yet",
+			staminaCost: 0
+		};
+		if (target.stamina < this.config.escapeStaminaCost) return {
+			success: false,
+			grappleControl,
+			reason: "Insufficient stamina",
+			staminaCost: 0
+		};
+		const escapeChance = this.calculateEscapeChance(grappleControl, controller, target);
+		if (Math.random() < escapeChance) return {
+			success: true,
+			grappleControl: null,
+			staminaCost: this.config.escapeStaminaCost
+		};
+		const weakenedGripStrength = Math.max(this.config.minGripStrength, grappleControl.gripStrength - 10);
+		return {
+			success: false,
+			grappleControl: {
+				...grappleControl,
+				gripStrength: weakenedGripStrength
+			},
+			reason: `Escape failed (${Math.round(escapeChance * 100)}% chance)`,
+			staminaCost: this.config.escapeStaminaCost
+		};
+	}
+	/**
+	* Calculate grip strength based on attacker attributes and target.
+	*
+	* **Korean**: 악력 계산 (Calculate Grip Strength)
+	*
+	* @private
+	*/
+	calculateGripStrength(attacker, target) {
+		let strength = attacker.attackPower * 3;
+		if (attacker.currentStance === TrigramStance.GON) strength *= 1.3;
+		else if (attacker.currentStance === TrigramStance.GAN) strength *= 1.15;
+		switch (target) {
+			case GrappleTarget.HAND:
+				strength *= 1.1;
+				break;
+			case GrappleTarget.ARM:
+				strength *= 1;
+				break;
+			case GrappleTarget.LEG:
+				strength *= .9;
+				break;
+			case GrappleTarget.TORSO:
+				strength *= .85;
+				break;
+			case GrappleTarget.NECK:
+				strength *= 1.2;
+				break;
+			case GrappleTarget.BOTH_ARMS:
+				strength *= .7;
+				break;
+		}
+		return Math.min(this.config.maxGripStrength, strength);
+	}
+	/**
+	* Calculate grapple success chance.
+	*
+	* **Korean**: 잡기 성공률 계산 (Calculate Grapple Success Chance)
+	*
+	* @private
+	*/
+	calculateGrappleSuccessChance(attacker, defender, target) {
+		let baseChance = .5 + (attacker.technique - defender.defense) * .02;
+		if (attacker.speed > defender.speed) baseChance += (attacker.speed - defender.speed) * .01;
+		if (attacker.currentStance === TrigramStance.GON) baseChance += .15;
+		if (defender.combatState === CombatState.ATTACKING) baseChance += .2;
+		else if (defender.combatState === CombatState.DEFENDING) baseChance -= .15;
+		switch (target) {
+			case GrappleTarget.HAND:
+				baseChance += .1;
+				break;
+			case GrappleTarget.BOTH_ARMS:
+				baseChance -= .2;
+				break;
+			case GrappleTarget.NECK:
+				baseChance -= .1;
+				break;
+		}
+		return Math.max(.05, Math.min(.95, baseChance));
+	}
+	/**
+	* Calculate escape chance from grapple.
+	*
+	* **Korean**: 탈출 성공률 계산 (Calculate Escape Chance)
+	*
+	* @private
+	*/
+	calculateEscapeChance(grappleControl, controller, target) {
+		let baseChance = .5 - grappleControl.gripStrength / this.config.maxGripStrength * .3;
+		const strengthDiff = target.attackPower - controller.attackPower;
+		baseChance += strengthDiff * .02;
+		if (target.speed > controller.speed) baseChance += (target.speed - controller.speed) * .015;
+		baseChance += target.technique * .005;
+		if (target.currentStance === TrigramStance.GON) baseChance += .3;
+		else if (target.currentStance === TrigramStance.GAN) baseChance += .15;
+		const durationSeconds = grappleControl.duration / 1e3;
+		const timePenalty = Math.min(.2, durationSeconds * .02);
+		baseChance -= timePenalty;
+		return Math.max(.05, Math.min(.85, baseChance));
+	}
+	/**
+	* Calculate stamina cost to maintain control.
+	*
+	* **Korean**: 체력 소모 계산 (Calculate Stamina Cost)
+	*
+	* @private
+	*/
+	calculateStaminaCost(target, gripStrength) {
+		let cost = this.config.baseStaminaCostPerSecond;
+		switch (target) {
+			case GrappleTarget.HAND:
+				cost *= .8;
+				break;
+			case GrappleTarget.ARM:
+				cost *= 1;
+				break;
+			case GrappleTarget.LEG:
+				cost *= 1.2;
+				break;
+			case GrappleTarget.TORSO:
+				cost *= 1.3;
+				break;
+			case GrappleTarget.NECK:
+				cost *= 1.5;
+				break;
+			case GrappleTarget.BOTH_ARMS:
+				cost *= 1.8;
+				break;
+		}
+		const gripFactor = gripStrength / this.config.maxGripStrength;
+		cost *= .7 + gripFactor * .6;
+		return cost;
+	}
+	/**
+	* Check if a grapple can be transitioned to a throw.
+	*
+	* **Korean**: 던지기 전환 확인 (Check Throw Transition)
+	*
+	* @param grappleControl - Current grapple control state
+	* @param controller - Player attempting throw
+	* @returns Whether throw transition is possible
+	*/
+	canTransitionToThrow(grappleControl, controller) {
+		if (grappleControl.duration < 1e3) return false;
+		if (grappleControl.gripStrength < 60) return false;
+		if (controller.stamina < 20) return false;
+		return [
+			GrappleTarget.ARM,
+			GrappleTarget.TORSO,
+			GrappleTarget.BOTH_ARMS
+		].includes(grappleControl.target);
+	}
+	/**
+	* Check if a grapple can be transitioned to a joint lock.
+	*
+	* **Korean**: 관절기 전환 확인 (Check Joint Lock Transition)
+	*
+	* @param grappleControl - Current grapple control state
+	* @param controller - Player attempting lock
+	* @returns Whether joint lock transition is possible
+	*/
+	canTransitionToJointLock(grappleControl, controller) {
+		if (grappleControl.duration < 800) return false;
+		if (controller.technique < 10) return false;
+		return [
+			GrappleTarget.HAND,
+			GrappleTarget.ARM,
+			GrappleTarget.LEG
+		].includes(grappleControl.target);
+	}
+	/**
+	* Get technique-specific control duration from Gon metadata.
+	*
+	* **Korean**: 기술별 제어 시간 조회 (Get Technique Control Duration)
+	*
+	* Retrieves the post-throw positional advantage duration from
+	* ExtendedGonTechnique metadata. Falls back to default duration
+	* if technique doesn't have Gon-specific enhancements.
+	*
+	* **Control Duration Philosophy**:
+	* - Traditional Ssireum techniques (800-2000ms) provide longer control
+	* - Aggressive slam techniques (800-1200ms) provide brief control
+	* - Sacrifice throws (1500-2000ms) provide extended ground control
+	*
+	* **Use Cases**:
+	* - Determining follow-up attack windows after throws
+	* - Calculating defender recovery time before counterattack
+	* - Applying post-throw positional advantage in game state
+	*
+	* @param technique - Korean martial arts technique (checks for ExtendedGonTechnique)
+	* @param defaultDuration - Fallback duration if technique has no metadata (default: 1000ms)
+	* @returns Control duration in milliseconds
+	*
+	* @example
+	* ```typescript
+	* const controlTime = grappleSystem.getTechniqueControlDuration(
+	*   ssireumThrowTechnique, // controlDuration: 1800
+	*   1000 // default fallback
+	* );
+	* // Result: 1800ms (uses technique metadata)
+	* ```
+	*
+	* @public
+	* @korean 기술별제어시간조회
+	*/
+	getTechniqueControlDuration(technique, defaultDuration = 1e3) {
+		const gonTechnique = asExtendedGonTechnique(technique);
+		if (!gonTechnique) return defaultDuration;
+		return gonTechnique.controlDuration;
+	}
+	/**
+	* Apply post-throw control advantage window.
+	*
+	* **Korean**: 던지기 후 우세 적용 (Apply Post-Throw Advantage)
+	*
+	* Creates a control advantage state after a successful throw,
+	* using the technique's `controlDuration` to determine how long
+	* the attacker maintains positional dominance.
+	*
+	* **Advantage Effects**:
+	* - Attacker gains priority for follow-up attacks
+	* - Defender must wait for control duration to expire
+	* - Applies to throw transitions from grapple control
+	*
+	* @param technique - Throw technique executed
+	* @param attackerId - Player who executed throw
+	* @param defenderId - Player who was thrown
+	* @param currentTime - Current game time in milliseconds
+	* @returns Control advantage state with duration from technique metadata
+	*
+	* @example
+	* ```typescript
+	* const advantage = grappleSystem.applyPostThrowAdvantage(
+	*   ssireumThrowTechnique,
+	*   "player1",
+	*   "player2",
+	*   Date.now()
+	* );
+	* // advantage.duration = 1800ms (from technique metadata)
+	* ```
+	*
+	* @public
+	* @korean 던지기후우세적용
+	*/
+	applyPostThrowAdvantage(technique, attackerId, defenderId, currentTime) {
+		const controlDuration = this.getTechniqueControlDuration(technique, 1200);
+		return {
+			controllerId: attackerId,
+			targetId: defenderId,
+			duration: controlDuration,
+			startTime: currentTime,
+			endTime: currentTime + controlDuration
+		};
+	}
+};
+//#endregion
+export { DEFAULT_GRAPPLE_CONFIG, GrappleSystem as default };
+
+//# sourceMappingURL=GrappleSystem.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"GrappleSystem.js","names":[],"sources":["../../../src/systems/combat/GrappleSystem.ts"],"sourcesContent":["/**\n * Grappling System for Korean Martial Arts Combat\n *\n * **Korean**: 잡기 시스템 (Grapple System)\n *\n * Implements realistic grappling and takedown mechanics based on:\n * - **Hapkido (합기도)**: Joint locks and control techniques\n * - **Ssireum (씨름)**: Traditional Korean wrestling\n * - **GON Stance (곤괘)**: Earth stance grounding and control\n *\n * ## Core Mechanics\n *\n * 1. **Grab Initiation**: Establish grip on opponent's limb/body\n * 2. **Control Duration**: Maintain control with stamina cost\n * 3. **Grip Strength**: Affects escape difficulty and follow-up options\n * 4. **Escape Mechanics**: Based on strength, technique, and stamina\n * 5. **Follow-up Techniques**: Throws, takedowns, joint locks from control\n *\n * ## Phase 2 Enhancement\n *\n * Enhanced with Gon (Earth) trigram metadata integration:\n * - Uses `controlDuration` from ExtendedGonTechnique\n * - Supports authentic Ssireum/Hapkido control durations\n * - Maintains backward compatibility with non-Gon techniques\n *\n * @module systems/combat/GrappleSystem\n * @category Combat System\n * @korean 잡기시스템\n */\n\nimport type { PlayerState } from \"@/systems/player\";\nimport {\n  CombatState,\n  GrappleControl,\n  GrappleState,\n  GrappleTarget,\n  TrigramStance,\n} from \"@/types\";\nimport { asExtendedGonTechnique } from \"../trigram/types/GonTechniqueExtensions\";\nimport type { KoreanTechnique } from \"../vitalpoint/types\";\n\n/**\n * Configuration for grappling mechanics.\n *\n * **Korean**: 잡기 설정 (Grapple Configuration)\n */\nexport interface GrappleConfig {\n  /** Base stamina cost per second to maintain control */\n  readonly baseStaminaCostPerSecond: number;\n  /** Minimum grip strength to maintain control */\n  readonly minGripStrength: number;\n  /** Maximum grip strength value */\n  readonly maxGripStrength: number;\n  /** Base escape difficulty multiplier */\n  readonly baseEscapeDifficulty: number;\n  /** Stamina cost to attempt escape */\n  readonly escapeStaminaCost: number;\n  /** Minimum duration before escape is possible (ms) */\n  readonly minControlDuration: number;\n}\n\n/**\n * Default grappling configuration values.\n */\nexport const DEFAULT_GRAPPLE_CONFIG: GrappleConfig = {\n  baseStaminaCostPerSecond: 5,\n  minGripStrength: 20,\n  maxGripStrength: 100,\n  baseEscapeDifficulty: 1.5,\n  escapeStaminaCost: 15,\n  minControlDuration: 500, // 0.5 seconds\n};\n\n/**\n * Grapple attempt result.\n *\n * **Korean**: 잡기 시도 결과 (Grapple Attempt Result)\n */\nexport interface GrappleAttemptResult {\n  /** Whether the grapple was successful */\n  readonly success: boolean;\n  /** New grapple control state if successful */\n  readonly grappleControl?: GrappleControl;\n  /** Reason for failure if unsuccessful */\n  readonly reason?: string;\n  /** Stamina cost for the attempt */\n  readonly staminaCost: number;\n}\n\n/**\n * Escape attempt result.\n *\n * **Korean**: 탈출 시도 결과 (Escape Attempt Result)\n */\nexport interface EscapeAttemptResult {\n  /** Whether the escape was successful */\n  readonly success: boolean;\n  /** Updated grapple control state */\n  readonly grappleControl: GrappleControl | null;\n  /** Reason for failure if unsuccessful */\n  readonly reason?: string;\n  /** Stamina cost for the attempt */\n  readonly staminaCost: number;\n}\n\n/**\n * Grappling System for control and hold mechanics.\n *\n * **Korean**: 잡기 시스템 (Grapple System)\n *\n * Manages grappling state between combatants, including grip strength,\n * control duration, escape mechanics, and follow-up techniques.\n */\nexport class GrappleSystem {\n  private readonly config: GrappleConfig;\n\n  constructor(config: Partial<GrappleConfig> = {}) {\n    this.config = { ...DEFAULT_GRAPPLE_CONFIG, ...config };\n  }\n\n  /**\n   * Attempt to initiate a grapple on target.\n   *\n   * **Korean**: 잡기 시도 (Attempt Grapple)\n   *\n   * @param attacker - Player attempting the grapple\n   * @param defender - Target player\n   * @param target - Body part to grapple\n   * @param currentTime - Current game time in milliseconds\n   * @returns Result of the grapple attempt\n   */\n  attemptGrapple(\n    attacker: PlayerState,\n    defender: PlayerState,\n    target: GrappleTarget,\n    currentTime: number\n  ): GrappleAttemptResult {\n    // Check if attacker can grapple\n    if (attacker.combatState === CombatState.STUNNED) {\n      return {\n        success: false,\n        reason: \"Attacker is stunned\",\n        staminaCost: 0,\n      };\n    }\n\n    // Check if attacker is already grappling someone else\n    if (attacker.combatState === CombatState.GRAPPLING) {\n      return {\n        success: false,\n        reason: \"Attacker is already grappling another opponent\",\n        staminaCost: 0,\n      };\n    }\n\n    if (attacker.stamina < this.config.escapeStaminaCost) {\n      return {\n        success: false,\n        reason: \"Insufficient stamina\",\n        staminaCost: 0,\n      };\n    }\n\n    // Check if defender is already being grappled\n    if (defender.combatState === CombatState.GRAPPLED) {\n      return {\n        success: false,\n        reason: \"Target is already being grappled\",\n        staminaCost: 0,\n      };\n    }\n\n    // Calculate grip strength based on attacker attributes and stance\n    const gripStrength = this.calculateGripStrength(attacker, target);\n\n    // Calculate success chance based on attributes\n    const successChance = this.calculateGrappleSuccessChance(\n      attacker,\n      defender,\n      target\n    );\n\n    const roll = Math.random();\n    const success = roll < successChance;\n\n    if (success) {\n      // Create grapple control - start with GRABBING state during initiation\n      const grappleControl: GrappleControl = {\n        state: GrappleState.GRABBING,\n        target,\n        controllerId: attacker.id,\n        targetId: defender.id,\n        gripStrength,\n        duration: 0,\n        startTime: currentTime,\n        canEscape: false, // Initially cannot escape\n        staminaCostPerSecond: this.calculateStaminaCost(target, gripStrength),\n      };\n\n      return {\n        success: true,\n        grappleControl,\n        staminaCost: this.config.escapeStaminaCost,\n      };\n    }\n\n    return {\n      success: false,\n      reason: `Grapple attempt failed (${Math.round(successChance * 100)}% chance)`,\n      staminaCost: this.config.escapeStaminaCost * 0.5, // Half cost on failure\n    };\n  }\n\n  /**\n   * Update grapple control state over time.\n   *\n   * **Korean**: 잡기 업데이트 (Update Grapple)\n   *\n   * @param grappleControl - Current grapple control state\n   * @param controller - Player maintaining control\n   * @param target - Player being controlled\n   * @param deltaTime - Time elapsed since last update (seconds)\n   * @param currentTime - Current game time in milliseconds\n   * @returns Updated grapple control or null if broken\n   */\n  updateGrapple(\n    grappleControl: GrappleControl,\n    controller: PlayerState,\n    _target: PlayerState,\n    deltaTime: number,\n    currentTime: number\n  ): GrappleControl | null {\n    // Check if controller can maintain control\n    if (\n      controller.stamina < grappleControl.staminaCostPerSecond * deltaTime ||\n      controller.combatState === CombatState.STUNNED\n    ) {\n      // Control broken due to stamina or state\n      return null;\n    }\n\n    // Update duration\n    const newDuration = currentTime - grappleControl.startTime;\n\n    // Transition from GRABBING to CONTROLLING after initial establishment\n    let newState = grappleControl.state;\n    if (grappleControl.state === GrappleState.GRABBING && newDuration > 0) {\n      newState = GrappleState.CONTROLLING;\n    }\n\n    // Decay grip strength slightly over time\n    const gripDecayRate = 2; // points per second\n    const rawGripStrength = grappleControl.gripStrength - gripDecayRate * deltaTime;\n\n    // Check if grip strength has dropped too low\n    if (rawGripStrength < this.config.minGripStrength) {\n      return null;\n    }\n\n    const newGripStrength = rawGripStrength;\n\n    // Allow escape attempts after minimum duration\n    const canEscape = newDuration >= this.config.minControlDuration;\n\n    return {\n      ...grappleControl,\n      state: newState,\n      gripStrength: newGripStrength,\n      duration: newDuration,\n      canEscape,\n    };\n  }\n\n  /**\n   * Attempt to escape from a grapple.\n   *\n   * **Korean**: 탈출 시도 (Attempt Escape)\n   *\n   * @param grappleControl - Current grapple control state\n   * @param controller - Player maintaining control\n   * @param target - Player attempting to escape\n   * @returns Result of the escape attempt\n   */\n  attemptEscape(\n    grappleControl: GrappleControl,\n    controller: PlayerState,\n    target: PlayerState\n  ): EscapeAttemptResult {\n    // Check if escape is possible\n    if (!grappleControl.canEscape) {\n      return {\n        success: false,\n        grappleControl,\n        reason: \"Cannot escape yet\",\n        staminaCost: 0,\n      };\n    }\n\n    // Check stamina\n    if (target.stamina < this.config.escapeStaminaCost) {\n      return {\n        success: false,\n        grappleControl,\n        reason: \"Insufficient stamina\",\n        staminaCost: 0,\n      };\n    }\n\n    // Calculate escape chance\n    const escapeChance = this.calculateEscapeChance(\n      grappleControl,\n      controller,\n      target\n    );\n\n    const roll = Math.random();\n    const success = roll < escapeChance;\n\n    if (success) {\n      return {\n        success: true,\n        grappleControl: null, // Escape successful, control broken\n        staminaCost: this.config.escapeStaminaCost,\n      };\n    }\n\n    // Escape failed, weaken grip slightly\n    const weakenedGripStrength = Math.max(\n      this.config.minGripStrength,\n      grappleControl.gripStrength - 10\n    );\n\n    return {\n      success: false,\n      grappleControl: {\n        ...grappleControl,\n        gripStrength: weakenedGripStrength,\n      },\n      reason: `Escape failed (${Math.round(escapeChance * 100)}% chance)`,\n      staminaCost: this.config.escapeStaminaCost,\n    };\n  }\n\n  /**\n   * Calculate grip strength based on attacker attributes and target.\n   *\n   * **Korean**: 악력 계산 (Calculate Grip Strength)\n   *\n   * @private\n   */\n  private calculateGripStrength(\n    attacker: PlayerState,\n    target: GrappleTarget\n  ): number {\n    // Base strength from attack power\n    let strength = attacker.attackPower * 3;\n\n    // Stance modifiers\n    if (attacker.currentStance === TrigramStance.GON) {\n      strength *= 1.3; // GON stance excels at grappling\n    } else if (attacker.currentStance === TrigramStance.GAN) {\n      strength *= 1.15; // GAN stance is also good for control\n    }\n\n    // Target modifiers\n    switch (target) {\n      case GrappleTarget.HAND:\n        strength *= 1.1; // Easier to control hand\n        break;\n      case GrappleTarget.ARM:\n        strength *= 1.0; // Standard difficulty\n        break;\n      case GrappleTarget.LEG:\n        strength *= 0.9; // Harder to control leg\n        break;\n      case GrappleTarget.TORSO:\n        strength *= 0.85; // Harder to control torso\n        break;\n      case GrappleTarget.NECK:\n        strength *= 1.2; // High control but risky\n        break;\n      case GrappleTarget.BOTH_ARMS:\n        strength *= 0.7; // Very hard to control both arms\n        break;\n    }\n\n    return Math.min(this.config.maxGripStrength, strength);\n  }\n\n  /**\n   * Calculate grapple success chance.\n   *\n   * **Korean**: 잡기 성공률 계산 (Calculate Grapple Success Chance)\n   *\n   * @private\n   */\n  private calculateGrappleSuccessChance(\n    attacker: PlayerState,\n    defender: PlayerState,\n    target: GrappleTarget\n  ): number {\n    // Base chance from technique vs defense\n    const attributeDiff = attacker.technique - defender.defense;\n    let baseChance = 0.5 + attributeDiff * 0.02; // ±2% per point difference\n\n    // Speed advantage\n    if (attacker.speed > defender.speed) {\n      baseChance += (attacker.speed - defender.speed) * 0.01;\n    }\n\n    // Stance modifiers\n    if (attacker.currentStance === TrigramStance.GON) {\n      baseChance += 0.15; // GON stance excels at grappling\n    }\n\n    if (defender.combatState === CombatState.ATTACKING) {\n      baseChance += 0.2; // Easier to grapple during attack\n    } else if (defender.combatState === CombatState.DEFENDING) {\n      baseChance -= 0.15; // Harder to grapple defensive opponent\n    }\n\n    // Target difficulty\n    switch (target) {\n      case GrappleTarget.HAND:\n        baseChance += 0.1; // Easier to grab hand\n        break;\n      case GrappleTarget.BOTH_ARMS:\n        baseChance -= 0.2; // Much harder to grab both arms\n        break;\n      case GrappleTarget.NECK:\n        baseChance -= 0.1; // Risky target\n        break;\n    }\n\n    // Clamp between 0.05 and 0.95\n    return Math.max(0.05, Math.min(0.95, baseChance));\n  }\n\n  /**\n   * Calculate escape chance from grapple.\n   *\n   * **Korean**: 탈출 성공률 계산 (Calculate Escape Chance)\n   *\n   * @private\n   */\n  private calculateEscapeChance(\n    grappleControl: GrappleControl,\n    controller: PlayerState,\n    target: PlayerState\n  ): number {\n    // Base chance from strength vs grip\n    const gripFactor = grappleControl.gripStrength / this.config.maxGripStrength;\n    let baseChance = 0.5 - gripFactor * 0.3; // Stronger grip = harder escape\n\n    // Attribute comparison\n    const strengthDiff = target.attackPower - controller.attackPower;\n    baseChance += strengthDiff * 0.02;\n\n    // Speed advantage helps escape\n    if (target.speed > controller.speed) {\n      baseChance += (target.speed - controller.speed) * 0.015;\n    }\n\n    // Technique helps find weaknesses in grip\n    baseChance += target.technique * 0.005;\n\n    // Stance modifiers - certain stances are better at escaping grapples\n    // **Korean**: 곤(坤) 자세는 탈출에 유리 (+30%), 간(艮) 자세는 방어적인 탈출 (+15%)\n    if (target.currentStance === TrigramStance.GON) {\n      baseChance += 0.3; // GON stance excels at grounding and escape\n    } else if (target.currentStance === TrigramStance.GAN) {\n      baseChance += 0.15; // GAN stance has defensive escape advantage\n    }\n\n    // Time factor - longer control makes escape harder\n    const durationSeconds = grappleControl.duration / 1000;\n    const timePenalty = Math.min(0.2, durationSeconds * 0.02);\n    baseChance -= timePenalty;\n\n    // Clamp between 0.05 and 0.85\n    return Math.max(0.05, Math.min(0.85, baseChance));\n  }\n\n  /**\n   * Calculate stamina cost to maintain control.\n   *\n   * **Korean**: 체력 소모 계산 (Calculate Stamina Cost)\n   *\n   * @private\n   */\n  private calculateStaminaCost(\n    target: GrappleTarget,\n    gripStrength: number\n  ): number {\n    let cost = this.config.baseStaminaCostPerSecond;\n\n    // Target affects stamina cost\n    switch (target) {\n      case GrappleTarget.HAND:\n        cost *= 0.8; // Easier to maintain\n        break;\n      case GrappleTarget.ARM:\n        cost *= 1.0; // Standard\n        break;\n      case GrappleTarget.LEG:\n        cost *= 1.2; // Harder to maintain\n        break;\n      case GrappleTarget.TORSO:\n        cost *= 1.3; // Much harder to maintain\n        break;\n      case GrappleTarget.NECK:\n        cost *= 1.5; // Very demanding\n        break;\n      case GrappleTarget.BOTH_ARMS:\n        cost *= 1.8; // Extremely demanding\n        break;\n    }\n\n    // Higher grip strength costs more stamina\n    const gripFactor = gripStrength / this.config.maxGripStrength;\n    cost *= 0.7 + gripFactor * 0.6; // 70-130% based on grip\n\n    return cost;\n  }\n\n  /**\n   * Check if a grapple can be transitioned to a throw.\n   *\n   * **Korean**: 던지기 전환 확인 (Check Throw Transition)\n   *\n   * @param grappleControl - Current grapple control state\n   * @param controller - Player attempting throw\n   * @returns Whether throw transition is possible\n   */\n  canTransitionToThrow(\n    grappleControl: GrappleControl,\n    controller: PlayerState\n  ): boolean {\n    // Need sufficient control duration\n    if (grappleControl.duration < 1000) {\n      return false; // Need at least 1 second of control\n    }\n\n    // Need sufficient grip strength\n    if (grappleControl.gripStrength < 60) {\n      return false;\n    }\n\n    // Need sufficient stamina for throw\n    if (controller.stamina < 20) {\n      return false;\n    }\n\n    // Certain targets are better for throws\n    const goodThrowTargets = [\n      GrappleTarget.ARM,\n      GrappleTarget.TORSO,\n      GrappleTarget.BOTH_ARMS,\n    ];\n\n    return goodThrowTargets.includes(grappleControl.target);\n  }\n\n  /**\n   * Check if a grapple can be transitioned to a joint lock.\n   *\n   * **Korean**: 관절기 전환 확인 (Check Joint Lock Transition)\n   *\n   * @param grappleControl - Current grapple control state\n   * @param controller - Player attempting lock\n   * @returns Whether joint lock transition is possible\n   */\n  canTransitionToJointLock(\n    grappleControl: GrappleControl,\n    controller: PlayerState\n  ): boolean {\n    // Need sufficient control duration\n    if (grappleControl.duration < 800) {\n      return false;\n    }\n\n    // Need high technique for joint locks\n    if (controller.technique < 10) {\n      return false;\n    }\n\n    // Joint locks work on limbs\n    const lockTargets = [\n      GrappleTarget.HAND,\n      GrappleTarget.ARM,\n      GrappleTarget.LEG,\n    ];\n\n    return lockTargets.includes(grappleControl.target);\n  }\n\n  /**\n   * Get technique-specific control duration from Gon metadata.\n   *\n   * **Korean**: 기술별 제어 시간 조회 (Get Technique Control Duration)\n   *\n   * Retrieves the post-throw positional advantage duration from\n   * ExtendedGonTechnique metadata. Falls back to default duration\n   * if technique doesn't have Gon-specific enhancements.\n   *\n   * **Control Duration Philosophy**:\n   * - Traditional Ssireum techniques (800-2000ms) provide longer control\n   * - Aggressive slam techniques (800-1200ms) provide brief control\n   * - Sacrifice throws (1500-2000ms) provide extended ground control\n   *\n   * **Use Cases**:\n   * - Determining follow-up attack windows after throws\n   * - Calculating defender recovery time before counterattack\n   * - Applying post-throw positional advantage in game state\n   *\n   * @param technique - Korean martial arts technique (checks for ExtendedGonTechnique)\n   * @param defaultDuration - Fallback duration if technique has no metadata (default: 1000ms)\n   * @returns Control duration in milliseconds\n   *\n   * @example\n   * ```typescript\n   * const controlTime = grappleSystem.getTechniqueControlDuration(\n   *   ssireumThrowTechnique, // controlDuration: 1800\n   *   1000 // default fallback\n   * );\n   * // Result: 1800ms (uses technique metadata)\n   * ```\n   *\n   * @public\n   * @korean 기술별제어시간조회\n   */\n  getTechniqueControlDuration(\n    technique: KoreanTechnique,\n    defaultDuration: number = 1000,\n  ): number {\n    // Use helper function for safe type casting\n    const gonTechnique = asExtendedGonTechnique(technique);\n    if (!gonTechnique) {\n      // Non-Gon technique: use default duration\n      return defaultDuration;\n    }\n\n    // Extract control duration from validated Gon technique\n    return gonTechnique.controlDuration;\n  }\n\n  /**\n   * Apply post-throw control advantage window.\n   *\n   * **Korean**: 던지기 후 우세 적용 (Apply Post-Throw Advantage)\n   *\n   * Creates a control advantage state after a successful throw,\n   * using the technique's `controlDuration` to determine how long\n   * the attacker maintains positional dominance.\n   *\n   * **Advantage Effects**:\n   * - Attacker gains priority for follow-up attacks\n   * - Defender must wait for control duration to expire\n   * - Applies to throw transitions from grapple control\n   *\n   * @param technique - Throw technique executed\n   * @param attackerId - Player who executed throw\n   * @param defenderId - Player who was thrown\n   * @param currentTime - Current game time in milliseconds\n   * @returns Control advantage state with duration from technique metadata\n   *\n   * @example\n   * ```typescript\n   * const advantage = grappleSystem.applyPostThrowAdvantage(\n   *   ssireumThrowTechnique,\n   *   \"player1\",\n   *   \"player2\",\n   *   Date.now()\n   * );\n   * // advantage.duration = 1800ms (from technique metadata)\n   * ```\n   *\n   * @public\n   * @korean 던지기후우세적용\n   */\n  applyPostThrowAdvantage(\n    technique: KoreanTechnique,\n    attackerId: string,\n    defenderId: string,\n    currentTime: number,\n  ): {\n    controllerId: string;\n    targetId: string;\n    duration: number;\n    startTime: number;\n    endTime: number;\n  } {\n    // Get technique-specific control duration with 1200ms fallback\n    const controlDuration = this.getTechniqueControlDuration(technique, 1200);\n\n    return {\n      controllerId: attackerId,\n      targetId: defenderId,\n      duration: controlDuration,\n      startTime: currentTime,\n      endTime: currentTime + controlDuration,\n    };\n  }\n}\n\nexport default GrappleSystem;\n"],"mappings":"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"}

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

@@ -0,0 +1,150 @@
+/**
+ * Limb Exposure System for Counter-Attack Detection
+ *
+ * **Korean**: 사지 노출 시스템 (Saji Nochul System)
+ *
+ * Analyzes technique animations to determine when limbs become exposed and vulnerable
+ * during attack execution. This enables:
+ * - Defensive counter-attacks (반격 - banggyeok)
+ * - Breaking techniques (파쇄기 - paswaegi)
+ * - Exploiting overextension (과다신장 약점 - gwada sinjang yakjeom)
+ *
+ * **Martial Arts Philosophy**:
+ * - **허점공격** (Heojeom Gonggyeok) - Attacking openings/weaknesses
+ * - **후수필승** (Husu Pilseung) - Victory through counter-attack timing
+ * - **이순응변** (Isun Eungbyeon) - Adapt and exploit opponent's mistakes
+ *
+ * @module systems/combat/LimbExposureSystem
+ * @korean 사지노출시스템
+ */
+import type { KoreanTechnique } from "../vitalpoint/types";
+import type { BreakingResult, BreakingTarget, CounterOpportunity, ExposedLimbType, LimbExposureWindow } from "../../types/physics";
+/**
+ * Calculate counter-attack opportunities from a technique's reach configuration.
+ *
+ * **Korean**: 반격 기회 계산
+ *
+ * Analyzes the technique's execution timeline and limb exposure to identify
+ * windows where the opponent is vulnerable to counter-attacks.
+ *
+ * @param technique - The technique being executed
+ * @param currentTime - Current time in technique execution (ms)
+ * @returns Counter opportunity if one exists, undefined otherwise
+ *
+ * @public
+ * @korean 반격기회계산
+ */
+export declare function calculateCounterOpportunity(technique: KoreanTechnique, currentTime: number): CounterOpportunity | undefined;
+/**
+ * Calculate vulnerability multiplier for a technique at a specific time.
+ *
+ * **Korean**: 취약성 배수 계산
+ *
+ * Determines how vulnerable the attacker is at a given point in their
+ * technique execution. Useful for damage calculation during counter-attacks.
+ *
+ * @param technique - The technique being executed
+ * @param currentTime - Current time in technique execution (ms)
+ * @returns Vulnerability multiplier (1.0 = normal, >1.0 = more vulnerable)
+ *
+ * @public
+ * @korean 취약성배수계산
+ */
+export declare function calculateVulnerabilityMultiplier(technique: KoreanTechnique, currentTime: number): number;
+/**
+ * Determine which limb is exposed based on technique and animation state.
+ *
+ * **Korean**: 노출된 사지 결정
+ *
+ * Analyzes the technique's body part and animation to determine which
+ * specific limb (left/right) is currently exposed.
+ *
+ * @param technique - The technique being executed
+ * @param isLeftSided - Whether the technique uses the left side
+ * @returns The exposed limb type
+ *
+ * @public
+ * @korean 노출사지결정
+ */
+export declare function determineExposedLimb(technique: KoreanTechnique, isLeftSided?: boolean): ExposedLimbType;
+/**
+ * Map exposed limb to breaking technique target.
+ *
+ * **Korean**: 노출 사지를 파쇄 목표로 매핑
+ *
+ * Converts an exposed limb type to the appropriate breaking target
+ * for joint and limb breaking techniques.
+ *
+ * @param exposedLimb - The exposed limb
+ * @returns The breaking target joint/bone
+ *
+ * @public
+ * @korean 파쇄목표매핑
+ */
+export declare function mapLimbToBreakingTarget(exposedLimb: ExposedLimbType): BreakingTarget;
+/**
+ * Calculate breaking technique effectiveness.
+ *
+ * **Korean**: 파쇄 기술 효과 계산
+ *
+ * Determines the result of a breaking technique applied to an exposed limb,
+ * considering the vulnerability window, force applied, and target joint.
+ *
+ * @param breakingTechnique - The breaking technique being applied (reserved for future use)
+ * @param counterOpportunity - The counter opportunity being exploited
+ * @param force - Force/damage of the breaking technique (typically 20-80 range)
+ * @returns Result of the breaking attempt
+ *
+ * @remarks
+ * The breakingTechnique parameter is currently unused but reserved for future
+ * extensibility. It may be used to apply technique-specific modifiers or
+ * validate technique compatibility with the breaking target.
+ *
+ * @public
+ * @korean 파쇄기술효과계산
+ */
+export declare function calculateBreakingResult(breakingTechnique: KoreanTechnique, counterOpportunity: CounterOpportunity, force: number): BreakingResult;
+/**
+ * Check if a defender can execute a counter-attack.
+ *
+ * **Korean**: 반격 실행 가능 여부 확인
+ *
+ * Validates whether a defender is in position and has the resources
+ * to execute a counter-attack against an exposed limb.
+ *
+ * @param defenderStamina - Defender's current stamina
+ * @param counterTechnique - The counter technique to execute
+ * @param distance - Distance between attacker and defender (meters)
+ * @returns Whether the counter can be executed
+ *
+ * @public
+ * @korean 반격실행가능확인
+ */
+export declare function canExecuteCounter(defenderStamina: number, counterTechnique: KoreanTechnique, distance: number): boolean;
+/**
+ * Generate limb exposure window for a technique.
+ *
+ * **Korean**: 사지 노출 시간 생성
+ *
+ * Creates a default limb exposure window for techniques that don't
+ * explicitly define one, based on heuristics from the technique type
+ * and reach configuration.
+ *
+ * @param technique - The technique to generate exposure for
+ * @returns Generated limb exposure window
+ *
+ * @public
+ * @korean 사지노출시간생성
+ */
+export declare function generateLimbExposureWindow(technique: KoreanTechnique): LimbExposureWindow;
+declare const _default: {
+    calculateCounterOpportunity: typeof calculateCounterOpportunity;
+    calculateVulnerabilityMultiplier: typeof calculateVulnerabilityMultiplier;
+    determineExposedLimb: typeof determineExposedLimb;
+    mapLimbToBreakingTarget: typeof mapLimbToBreakingTarget;
+    calculateBreakingResult: typeof calculateBreakingResult;
+    canExecuteCounter: typeof canExecuteCounter;
+    generateLimbExposureWindow: typeof generateLimbExposureWindow;
+};
+export default _default;
+//# sourceMappingURL=LimbExposureSystem.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"LimbExposureSystem.d.ts","sourceRoot":"","sources":["../../../src/systems/combat/LimbExposureSystem.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAC3D,OAAO,KAAK,EACV,cAAc,EACd,cAAc,EACd,kBAAkB,EAClB,eAAe,EACf,kBAAkB,EAEnB,MAAM,qBAAqB,CAAC;AA8B7B;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,2BAA2B,CACzC,SAAS,EAAE,eAAe,EAC1B,WAAW,EAAE,MAAM,GAClB,kBAAkB,GAAG,SAAS,CAkChC;AA2DD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,gCAAgC,CAC9C,SAAS,EAAE,eAAe,EAC1B,WAAW,EAAE,MAAM,GAClB,MAAM,CAoCR;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,oBAAoB,CAClC,SAAS,EAAE,eAAe,EAC1B,WAAW,GAAE,OAAe,GAC3B,eAAe,CAuCjB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,uBAAuB,CACrC,WAAW,EAAE,eAAe,GAC3B,cAAc,CAWhB;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,uBAAuB,CACrC,iBAAiB,EAAE,eAAe,EAClC,kBAAkB,EAAE,kBAAkB,EACtC,KAAK,EAAE,MAAM,GACZ,cAAc,CA4EhB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,iBAAiB,CAC/B,eAAe,EAAE,MAAM,EACvB,gBAAgB,EAAE,eAAe,EACjC,QAAQ,EAAE,MAAM,GACf,OAAO,CAYT;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,0BAA0B,CACxC,SAAS,EAAE,eAAe,GACzB,kBAAkB,CAqCpB;;;;;;;;;;AAED,wBAQE"}