blacktrigram 0.7.2

package/lib/systems/combat/BalanceSystem.js

@@ -0,0 +1,811 @@
+import { BodyRegion, TrigramStance } from "../../types/common.js";
+import "../../types/index.js";
+import { getRecoveryConfig, isVulnerableFrame } from "../animation/catalogs/RecoveryAnimations.js";
+import { determineFallDirection, determineFallFromStance } from "../animation/systems/FallAnimations.js";
+import "../animation/index.js";
+//#region src/systems/combat/BalanceSystem.ts
+/**
+* Balance System for managing stability and vulnerability windows.
+*
+* **Korean**: 균형 시스템 (Balance System)
+*
+* Implements physical balance and stability mechanics. Loss of balance creates
+* vulnerability windows where damage is increased and defensive options limited.
+* Balance is affected by:
+* - Leg strikes
+* - Throws and sweeps
+* - Heavy impacts
+* - Fatigue (low stamina)
+* - Stance transitions (0.5s vulnerability window)
+* - Body part damage (legs reduce balance)
+* - Rapid stance changes (penalty system)
+*
+* ## Balance States
+*
+* - **Stable**: 80-100 balance - Full mobility and defense
+* - **Unsteady**: 50-79 balance - Reduced evasion, slower movement
+* - **Off-Balance**: 20-49 balance - Vulnerability window, defense penalty
+* - **Falling**: 0-19 balance - Severe vulnerability, possible knockdown
+*
+* ## Fall System Integration
+*
+* When balance falls below 20%, the system can trigger fall animations (낙법).
+* Fall direction is determined by attack vector and player stance.
+*
+* ## Stance Transition Vulnerability
+*
+* Changing stances creates a 0.5s vulnerability window with 1.5x damage multiplier.
+* Rapid stance changes (>2 in 3s) apply additional 20% balance penalty for 2s.
+*
+* @module systems/combat/BalanceSystem
+* @category Combat System
+* @korean 균형시스템
+*/
+/**
+* Balance levels representing physical stability.
+*
+* **Korean**: 균형 수준
+*/
+var BalanceLevel = /* @__PURE__ */ function(BalanceLevel) {
+	/** Stable footing (80-100) */
+	BalanceLevel["STABLE"] = "stable";
+	/** Unsteady but controlled (50-79) */
+	BalanceLevel["UNSTEADY"] = "unsteady";
+	/** Off-balance, vulnerable (20-49) */
+	BalanceLevel["OFF_BALANCE"] = "off_balance";
+	/** Falling or knocked down (0-19) */
+	BalanceLevel["FALLING"] = "falling";
+	return BalanceLevel;
+}({});
+/**
+* Balance System managing stability and vulnerability.
+*
+* Balance represents physical stability and center of gravity control.
+* Low balance creates vulnerability windows where opponents can capitalize
+* with increased damage and reduced defensive options.
+*
+* @example
+* ```typescript
+* const balanceSystem = new BalanceSystem();
+*
+* // Apply balance disruption from leg strike
+* const newPlayer = balanceSystem.disruptBalance(
+*   player,
+*   15,
+*   BodyRegion.LEFT_LEG
+* );
+*
+* // Check if vulnerable
+* const isVulnerable = balanceSystem.isVulnerable(newPlayer);
+*
+* // Apply recovery
+* const recovered = balanceSystem.applyRecovery(newPlayer, 1000);
+* ```
+*
+* @public
+* @korean 균형시스템
+*/
+var BalanceSystem = class {
+	/**
+	* Balance level effects and thresholds.
+	*/
+	balanceEffects = {
+		[BalanceLevel.STABLE]: {
+			range: [80, 100],
+			defenseMultiplier: 1,
+			evasionModifier: 1,
+			movementSpeedMultiplier: 1,
+			vulnerabilityMultiplier: 1,
+			canEvade: true,
+			knockdownRisk: 0
+		},
+		[BalanceLevel.UNSTEADY]: {
+			range: [50, 79],
+			defenseMultiplier: .85,
+			evasionModifier: .7,
+			movementSpeedMultiplier: .85,
+			vulnerabilityMultiplier: 1.15,
+			canEvade: true,
+			knockdownRisk: .1
+		},
+		[BalanceLevel.OFF_BALANCE]: {
+			range: [20, 49],
+			defenseMultiplier: .6,
+			evasionModifier: .4,
+			movementSpeedMultiplier: .6,
+			vulnerabilityMultiplier: 1.5,
+			canEvade: false,
+			knockdownRisk: .3
+		},
+		[BalanceLevel.FALLING]: {
+			range: [0, 19],
+			defenseMultiplier: .3,
+			evasionModifier: 0,
+			movementSpeedMultiplier: .3,
+			vulnerabilityMultiplier: 2,
+			canEvade: false,
+			knockdownRisk: .8
+		}
+	};
+	/**
+	* Balance disruption multipliers by body region.
+	*/
+	regionMultipliers = {
+		[BodyRegion.LEFT_LEG]: 2.5,
+		[BodyRegion.RIGHT_LEG]: 2.5,
+		[BodyRegion.CORE]: 2,
+		[BodyRegion.TORSO]: 1.5,
+		[BodyRegion.HEAD]: 1,
+		default: .5
+	};
+	/**
+	* Base balance recovery rate per second.
+	*/
+	baseRecoveryRate = 8;
+	/**
+	* Maximum balance value.
+	*/
+	maxBalance = 100;
+	/**
+	* Stance transition constants.
+	*/
+	transitionDuration = 500;
+	transitionVulnerabilityMultiplier = 1.5;
+	/**
+	* Rapid stance change penalty constants.
+	*/
+	rapidChangeWindow = 3e3;
+	rapidChangeThreshold = 2;
+	rapidChangePenalty = .2;
+	rapidChangePenaltyDuration = 2e3;
+	stanceChangeHistoryLimit = 5;
+	/**
+	* Disrupts balance from combat impact.
+	*
+	* Calculates balance loss based on damage amount and body region hit.
+	* Leg strikes cause maximum balance disruption.
+	*
+	* Now also considers:
+	* - Body part damage modifier (damaged legs reduce balance more)
+	* - Rapid stance change penalty (20% additional reduction)
+	*
+	* @param player - Current player state
+	* @param impact - Impact force amount
+	* @param region - Body region affected
+	* @param currentTime - Current game time for penalty checks (optional)
+	* @returns Updated player state with reduced balance
+	*
+	* @example
+	* ```typescript
+	* // Leg sweep causes major balance disruption
+	* player = system.disruptBalance(
+	*   player,
+	*   20,
+	*   BodyRegion.RIGHT_LEG,
+	*   Date.now()
+	* );
+	* ```
+	*
+	* @public
+	* @korean 균형파괴
+	*/
+	disruptBalance(player, impact, region, currentTime) {
+		let balanceLoss = impact * (region ? this.regionMultipliers[region] ?? this.regionMultipliers.default : this.regionMultipliers.default) * .6;
+		const bodyModifier = this.calculateBalanceModifier(player);
+		balanceLoss *= 1 / bodyModifier;
+		if (currentTime !== void 0 && this.isRapidChangePenaltyActive(player, currentTime)) balanceLoss *= 1 + this.rapidChangePenalty;
+		const newBalance = Math.max(0, player.balance - balanceLoss);
+		return {
+			...player,
+			balance: newBalance
+		};
+	}
+	/**
+	* Applies balance recovery over time.
+	*
+	* Balance recovers quickly when not being disrupted, allowing
+	* fighters to regain stable footing between exchanges.
+	*
+	* Recovery is affected by:
+	* - Balance level (harder to recover when off-balance)
+	* - Stamina (low stamina = slow recovery)
+	* - Body part damage (leg damage reduces recovery rate)
+	*
+	* @param player - Current player state
+	* @param deltaTime - Time elapsed in milliseconds
+	* @returns Updated player state with recovered balance
+	*
+	* @example
+	* ```typescript
+	* // In game loop
+	* player = system.applyRecovery(player, 16); // ~60fps
+	* ```
+	*
+	* @public
+	* @korean 균형회복
+	*/
+	applyRecovery(player, deltaTime) {
+		if (player.balance >= this.maxBalance) return player;
+		const deltaSeconds = deltaTime / 1e3;
+		const level = this.getBalanceLevel(player.balance);
+		let recoveryModifier = 1;
+		if (level === BalanceLevel.OFF_BALANCE) recoveryModifier = .7;
+		else if (level === BalanceLevel.FALLING) recoveryModifier = .4;
+		const staminaFactor = player.stamina / player.maxStamina;
+		const bodyModifier = this.calculateBalanceModifier(player);
+		const finalModifier = recoveryModifier * (.5 + staminaFactor * .5) * bodyModifier;
+		const recovery = this.baseRecoveryRate * deltaSeconds * finalModifier;
+		const newBalance = Math.min(this.maxBalance, player.balance + recovery);
+		return {
+			...player,
+			balance: newBalance
+		};
+	}
+	/**
+	* Determines balance level from balance value.
+	*
+	* @param balance - Balance value (0-100)
+	* @returns Current balance level
+	*
+	* @public
+	* @korean 균형수준확인
+	*/
+	getBalanceLevel(balance) {
+		if (balance >= 80) return BalanceLevel.STABLE;
+		if (balance >= 50) return BalanceLevel.UNSTEADY;
+		if (balance >= 20) return BalanceLevel.OFF_BALANCE;
+		return BalanceLevel.FALLING;
+	}
+	/**
+	* Gets effects for a specific balance level.
+	*
+	* @param level - Balance level
+	* @returns Effects applied at that level
+	*
+	* @public
+	* @korean 균형효과
+	*/
+	getEffects(level) {
+		return this.balanceEffects[level];
+	}
+	/**
+	* Applies balance effects to player state.
+	*
+	* Modifies player stats based on current balance level.
+	*
+	* @param player - Current player state
+	* @returns Modified player state with balance effects
+	*
+	* @public
+	* @korean 균형효과적용
+	*/
+	applyEffects(player) {
+		const level = this.getBalanceLevel(player.balance);
+		const effects = this.getEffects(level);
+		return {
+			...player,
+			defense: Math.floor(player.defense * effects.defenseMultiplier),
+			speed: Math.floor(player.speed * effects.movementSpeedMultiplier)
+		};
+	}
+	/**
+	* Checks if player is vulnerable due to balance.
+	*
+	* @param player - Current player state
+	* @returns True if off-balance or falling
+	*
+	* @public
+	* @korean 균형취약확인
+	*/
+	isVulnerable(player) {
+		const level = this.getBalanceLevel(player.balance);
+		return level === BalanceLevel.OFF_BALANCE || level === BalanceLevel.FALLING;
+	}
+	/**
+	* Calculates damage multiplier for vulnerable balance state.
+	*
+	* @param player - Current player state
+	* @returns Damage multiplier (1.0 = normal, >1.0 = increased damage)
+	*
+	* @public
+	* @korean 취약성배율
+	*/
+	getVulnerabilityMultiplier(player) {
+		const level = this.getBalanceLevel(player.balance);
+		return this.getEffects(level).vulnerabilityMultiplier;
+	}
+	/**
+	* Checks if knockdown should occur, using a provided random function for determinism.
+	*
+	* @param player - Current player state
+	* @param randomFn - Optional random number generator (returns number in [0,1)), defaults to Math.random
+	* @returns True if knockdown should occur
+	*
+	* @public
+	* @korean 넘어짐확인
+	*/
+	shouldKnockdown(player, randomFn = Math.random) {
+		const level = this.getBalanceLevel(player.balance);
+		const effects = this.getEffects(level);
+		return randomFn() < effects.knockdownRisk;
+	}
+	/**
+	* Gets bilingual name for balance level.
+	*
+	* @param level - Balance level
+	* @returns Korean and English level names
+	*
+	* @public
+	* @korean 균형이름
+	*/
+	getLevelName(level) {
+		return {
+			[BalanceLevel.STABLE]: {
+				korean: "안정",
+				english: "Stable"
+			},
+			[BalanceLevel.UNSTEADY]: {
+				korean: "불안정",
+				english: "Unsteady"
+			},
+			[BalanceLevel.OFF_BALANCE]: {
+				korean: "균형상실",
+				english: "Off-Balance"
+			},
+			[BalanceLevel.FALLING]: {
+				korean: "낙하중",
+				english: "Falling"
+			}
+		}[level];
+	}
+	/**
+	* Gets color indicator for balance level (for UI).
+	*
+	* @param level - Balance level
+	* @returns Hex color code
+	*
+	* @public
+	* @korean 균형색상
+	*/
+	getLevelColor(level) {
+		return {
+			[BalanceLevel.STABLE]: 65280,
+			[BalanceLevel.UNSTEADY]: 16776960,
+			[BalanceLevel.OFF_BALANCE]: 16746496,
+			[BalanceLevel.FALLING]: 16711680
+		}[level];
+	}
+	/**
+	* Checks if balance is low enough to trigger fall animation.
+	*
+	* Falls occur when balance drops below 20% (FALLING state).
+	* This creates realistic knockdown conditions from balance loss.
+	*
+	* @param player - Current player state
+	* @returns True if fall animation should trigger
+	*
+	* @example
+	* ```typescript
+	* if (balanceSystem.shouldTriggerFall(player)) {
+	*   const fallType = balanceSystem.determineFallType(
+	*     player,
+	*     attackAngle,
+	*     attackHeight
+	*   );
+	*   animationMachine.transitionTo(FALL_TYPE_TO_ANIMATION[fallType]);
+	* }
+	* ```
+	*
+	* @public
+	* @korean 낙법발동확인
+	*/
+	shouldTriggerFall(player) {
+		return player.balance < 20;
+	}
+	/**
+	* Determines which fall animation to play based on attack and stance.
+	*
+	* Calculates fall direction using:
+	* - Attack angle relative to player
+	* - Attack height (high/mid/low)
+	* - Player's current stance bias
+	*
+	* Korean falling techniques (낙법):
+	* - 전방낙법 (Jeonbang Nakbeop): Forward fall
+	* - 후방낙법 (Hubang Nakbeop): Backward fall
+	* - 측방낙법 (Cheukbang Nakbeop): Side fall
+	*
+	* @param player - Current player state
+	* @param attackAngle - Angle of attack in radians (0 = from front)
+	* @param attackHeight - Attack height: 'high', 'mid', or 'low'
+	* @returns Fall type to use for animation
+	*
+	* @example
+	* ```typescript
+	* // Player facing forward (0°), attacked from behind (π)
+	* const fallType = balanceSystem.determineFallType(
+	*   player,
+	*   Math.PI,
+	*   'mid'
+	* );
+	* // Returns: 'forward' (pushed forward by rear attack)
+	*
+	* // Low sweep from right side
+	* const fallType = balanceSystem.determineFallType(
+	*   player,
+	*   Math.PI/2,
+	*   'low'
+	* );
+	* // Returns: 'side_right' (swept to the side)
+	* ```
+	*
+	* @public
+	* @korean 낙법유형결정
+	*/
+	determineFallType(_player, attackAngle, attackHeight = "mid") {
+		return determineFallDirection(attackAngle, 0, attackHeight);
+	}
+	/**
+	* Determines fall type based on player stance when no attack direction available.
+	*
+	* Uses stance bias to determine likely fall direction when balance is lost
+	* without a specific attack (e.g., from fatigue, leg damage accumulation).
+	*
+	* @param stance - Current trigram stance
+	* @returns Fall type based on stance characteristics
+	*
+	* @example
+	* ```typescript
+	* // Player in Heaven stance (aggressive forward)
+	* const fallType = balanceSystem.determineFallTypeFromStance(
+	*   TrigramStance.GEON
+	* );
+	* // Returns: 'forward' (Heaven stance has forward bias)
+	* ```
+	*
+	* @public
+	* @korean 자세낙법결정
+	*/
+	determineFallTypeFromStance(stance) {
+		return determineFallFromStance(stance);
+	}
+	/**
+	* Check if player is in a grounded state based on animation state.
+	*
+	* Player is considered grounded when in any ground_* animation state
+	* (ground_prone, ground_supine, ground_side_left, ground_side_right).
+	*
+	* @param animationState - Current animation state from AnimationStateMachine
+	* @returns True if player is on the ground
+	*
+	* @example
+	* ```typescript
+	* const isGrounded = balanceSystem.isGrounded("ground_prone");
+	* // Returns: true
+	*
+	* const notGrounded = balanceSystem.isGrounded("idle");
+	* // Returns: false
+	* ```
+	*
+	* @public
+	* @korean 지면상태확인
+	*/
+	isGrounded(animationState) {
+		return animationState.startsWith("ground_");
+	}
+	/**
+	* Get ground state from animation state.
+	*
+	* Extracts the ground position type from animation state name.
+	* Returns null if not in a ground state.
+	*
+	* @param animationState - Current animation state from AnimationStateMachine
+	* @returns Ground state or null if not grounded
+	*
+	* @example
+	* ```typescript
+	* const state = balanceSystem.getGroundState("ground_prone");
+	* // Returns: "prone"
+	*
+	* const none = balanceSystem.getGroundState("idle");
+	* // Returns: null
+	* ```
+	*
+	* @public
+	* @korean 지면자세가져오기
+	*/
+	getGroundState(animationState) {
+		if (!this.isGrounded(animationState)) return null;
+		const groundType = animationState.replace("ground_", "");
+		if (groundType === "prone" || groundType === "supine" || groundType === "side_left" || groundType === "side_right") return groundType;
+		return null;
+	}
+	/**
+	* Check if player can execute recovery based on stamina.
+	*
+	* Some recovery animations (like roll recovery) require stamina.
+	* This checks if player has sufficient stamina for the recovery type.
+	*
+	* @param player - Current player state
+	* @param recoveryType - Type of recovery animation
+	* @returns True if player has enough stamina
+	*
+	* @example
+	* ```typescript
+	* // Roll recovery costs 20 stamina
+	* const canRoll = balanceSystem.canRecoverWithType(player, "roll_recovery");
+	* // Returns: true if player.stamina >= 20
+	*
+	* // Normal recoveries have no cost
+	* const canStand = balanceSystem.canRecoverWithType(player, "prone_standup");
+	* // Returns: true (no stamina requirement)
+	* ```
+	*
+	* @public
+	* @korean 회복가능확인
+	*/
+	canRecoverWithType(player, recoveryType) {
+		const config = getRecoveryConfig(recoveryType);
+		return player.stamina >= config.staminaCost;
+	}
+	/**
+	* Apply stamina cost for recovery animation.
+	*
+	* Deducts stamina cost from player state for recovery animations
+	* that require stamina (like roll recovery).
+	*
+	* @param player - Current player state
+	* @param recoveryType - Type of recovery animation
+	* @returns Updated player state with stamina deducted
+	*
+	* @example
+	* ```typescript
+	* // Roll recovery costs 20 stamina
+	* const recovered = balanceSystem.applyRecoveryCost(player, "roll_recovery");
+	* // recovered.stamina = player.stamina - 20
+	* ```
+	*
+	* @public
+	* @korean 회복비용적용
+	*/
+	applyRecoveryCost(player, recoveryType) {
+		const config = getRecoveryConfig(recoveryType);
+		if (config.staminaCost === 0) return player;
+		return {
+			...player,
+			stamina: Math.max(0, player.stamina - config.staminaCost)
+		};
+	}
+	/**
+	* Get damage multiplier during recovery animation.
+	*
+	* Some recovery animations (like defensive getup) provide damage reduction.
+	* This returns the multiplier to apply to incoming damage.
+	*
+	* @param recoveryType - Type of recovery animation
+	* @param currentFrame - Current frame in the animation
+	* @returns Damage multiplier (1.0 = normal, 0.5 = 50% reduction)
+	*
+	* @example
+	* ```typescript
+	* // Defensive getup has 50% damage reduction
+	* const multiplier = balanceSystem.getRecoveryDamageMultiplier("defensive_getup", 20);
+	* // Returns: 0.5 (50% damage reduction)
+	*
+	* // Normal recoveries have no reduction
+	* const normal = balanceSystem.getRecoveryDamageMultiplier("prone_standup", 15);
+	* // Returns: 1.0 (full damage)
+	* ```
+	*
+	* @public
+	* @korean 회복피해배율
+	*/
+	getRecoveryDamageMultiplier(recoveryType, currentFrame) {
+		const config = getRecoveryConfig(recoveryType);
+		if (!isVulnerableFrame(recoveryType, currentFrame)) return 1;
+		return 1 - config.damageReduction;
+	}
+	/**
+	* Start a stance transition, creating vulnerability window.
+	*
+	* When a player changes stance, they become vulnerable for 0.5s with
+	* a 1.5x damage multiplier. This creates tactical depth around stance changes.
+	*
+	* @param player - Current player state
+	* @param newStance - Target stance to transition to
+	* @param currentTime - Current game time in milliseconds
+	* @returns Updated player state with transition tracking
+	*
+	* @example
+	* ```typescript
+	* // Player switches from Heaven to Water stance
+	* const transitioning = balanceSystem.startStanceTransition(
+	*   player,
+	*   TrigramStance.GAM,
+	*   Date.now()
+	* );
+	* // transitioning.transitionState.isTransitioning = true
+	* // transitioning.transitionState.vulnerabilityMultiplier = 1.5
+	* ```
+	*
+	* @public
+	* @korean 자세전환시작
+	*/
+	startStanceTransition(player, newStance, currentTime) {
+		if (newStance === player.currentStance) return player;
+		const transitionState = {
+			isTransitioning: true,
+			transitionStartTime: currentTime,
+			vulnerabilityMultiplier: this.transitionVulnerabilityMultiplier,
+			fromStance: player.currentStance,
+			toStance: newStance
+		};
+		const historyEntry = {
+			timestamp: currentTime,
+			fromStance: player.currentStance,
+			toStance: newStance
+		};
+		const newHistory = [...player.stanceChangeHistory ?? [], historyEntry].slice(-this.stanceChangeHistoryLimit);
+		const recentChanges = newHistory.filter((entry) => currentTime - entry.timestamp <= this.rapidChangeWindow);
+		let rapidChangePenaltyEnd = player.rapidChangePenaltyEnd;
+		if (recentChanges.length > this.rapidChangeThreshold) rapidChangePenaltyEnd = currentTime + this.rapidChangePenaltyDuration;
+		return {
+			...player,
+			currentStance: newStance,
+			lastStanceChangeTime: currentTime,
+			transitionState,
+			stanceChangeHistory: newHistory,
+			rapidChangePenaltyEnd
+		};
+	}
+	/**
+	* Update stance transition state based on time elapsed.
+	*
+	* Transitions last 0.5s. After that, vulnerability window closes.
+	* Called each frame to manage transition timing.
+	*
+	* @param player - Current player state
+	* @param currentTime - Current game time in milliseconds
+	* @returns Updated player state
+	*
+	* @example
+	* ```typescript
+	* // In game loop
+	* player = balanceSystem.updateTransition(player, Date.now());
+	* ```
+	*
+	* @public
+	* @korean 전환상태갱신
+	*/
+	updateTransition(player, currentTime) {
+		if (!player.transitionState?.isTransitioning) return player;
+		if (currentTime - player.transitionState.transitionStartTime >= this.transitionDuration) return {
+			...player,
+			transitionState: {
+				...player.transitionState,
+				isTransitioning: false,
+				vulnerabilityMultiplier: 1
+			}
+		};
+		return player;
+	}
+	/**
+	* Calculate balance modifier based on body part damage.
+	*
+	* Leg damage significantly reduces balance. The leg-specific modifier
+	* scales linearly from 0.7x at 0% leg health to 1.0x at 100% leg health:
+	* - 100% leg health: 1.0x balance (no reduction from legs)
+	* - 70% leg health: ≈0.91x balance (≈9% reduction from legs)
+	* - 30% leg health: ≈0.79x balance (≈21% reduction from legs)
+	* - 0% leg health: 0.7x balance (30% reduction from legs)
+	*
+	* Torso damage also affects balance but to a lesser degree, and the
+	* combined leg/torso modifier is clamped so the final balance modifier
+	* stays within the range 0.5x to 1.0x.
+	*
+	* @param player - Current player state with body part health
+	* @returns Balance modifier (0.5 to 1.0)
+	*
+	* @example
+	* ```typescript
+	* const modifier = balanceSystem.calculateBalanceModifier(player);
+	* const effectiveBalance = player.balance * modifier;
+	* ```
+	*
+	* @public
+	* @korean 균형조정계수계산
+	*/
+	calculateBalanceModifier(player) {
+		if (!player.bodyPartHealth || !player.bodyPartMaxHealth) return 1;
+		const leftLegHealthRaw = (player.bodyPartHealth.legLeft ?? 0) / (player.bodyPartMaxHealth.legLeft ?? 1);
+		const rightLegHealthRaw = (player.bodyPartHealth.legRight ?? 0) / (player.bodyPartMaxHealth.legRight ?? 1);
+		const torsoHealthRaw = (player.bodyPartHealth.torsoLower ?? 0) / (player.bodyPartMaxHealth.torsoLower ?? 1);
+		const leftLegHealth = Math.max(0, Math.min(1, leftLegHealthRaw));
+		const rightLegHealth = Math.max(0, Math.min(1, rightLegHealthRaw));
+		const torsoHealth = Math.max(0, Math.min(1, torsoHealthRaw));
+		const combinedModifier = (.7 + (leftLegHealth + rightLegHealth) / 2 * .3) * (.9 + torsoHealth * .1);
+		return Math.max(.5, Math.min(1, combinedModifier));
+	}
+	/**
+	* Calculate knockback resistance based on current stance.
+	*
+	* Different stances provide varying levels of knockback resistance:
+	* - Defensive stances (Mountain, Earth): +50% resistance
+	* - Balanced stances (Water, Wind): normal resistance
+	* - Offensive stances (Heaven, Fire, Thunder): -30% resistance
+	* - Fluid stance (Lake): normal resistance
+	*
+	* @param stance - Current trigram stance
+	* @returns Knockback resistance multiplier (0.7 to 1.5)
+	*
+	* @example
+	* ```typescript
+	* const resistance = balanceSystem.getKnockbackResistance(TrigramStance.GAN);
+	* const effectiveKnockback = baseKnockback * (1.0 / resistance);
+	* ```
+	*
+	* @public
+	* @korean 넉백저항계산
+	*/
+	getKnockbackResistance(stance) {
+		if (stance === TrigramStance.GAN || stance === TrigramStance.GON) return 1.5;
+		if (stance === TrigramStance.GEON || stance === TrigramStance.LI || stance === TrigramStance.JIN) return .7;
+		return 1;
+	}
+	/**
+	* Check if rapid stance change penalty is active.
+	*
+	* Penalty applies when player changes stances >2 times in 3 seconds.
+	* Lasts for 2 seconds after the last rapid change.
+	* The penalty increases balance loss by 20% in `disruptBalance()`.
+	*
+	* @param player - Current player state
+	* @param currentTime - Current game time in milliseconds
+	* @returns True if penalty is active
+	*
+	* @example
+	* ```typescript
+	* // The penalty is applied automatically in disruptBalance()
+	* if (balanceSystem.isRapidChangePenaltyActive(player, Date.now())) {
+	*   // Penalty active: balance loss will be increased by 20%
+	*   cy.log("Rapid change penalty active");
+	* }
+	* ```
+	*
+	* @public
+	* @korean 급속변경벌칙확인
+	*/
+	isRapidChangePenaltyActive(player, currentTime) {
+		if (!player.rapidChangePenaltyEnd) return false;
+		return currentTime < player.rapidChangePenaltyEnd;
+	}
+	/**
+	* Get total vulnerability multiplier considering all factors.
+	*
+	* Combines:
+	* - Base balance state vulnerability (1.0 to 2.0)
+	* - Stance transition vulnerability (1.5x during 0.5s window)
+	*
+	* @param player - Current player state
+	* @returns Combined vulnerability multiplier
+	*
+	* @example
+	* ```typescript
+	* const multiplier = balanceSystem.getTotalVulnerabilityMultiplier(player);
+	* const finalDamage = baseDamage * multiplier;
+	* ```
+	*
+	* @public
+	* @korean 총취약성배율
+	*/
+	getTotalVulnerabilityMultiplier(player) {
+		const level = this.getBalanceLevel(player.balance);
+		let multiplier = this.getEffects(level).vulnerabilityMultiplier;
+		if (player.transitionState?.isTransitioning) multiplier *= player.transitionState.vulnerabilityMultiplier;
+		return multiplier;
+	}
+};
+//#endregion
+export { BalanceLevel, BalanceSystem as default };
+
+//# sourceMappingURL=BalanceSystem.js.map