blacktrigram 0.7.2

package/lib/systems/animation/systems/BodyFacingSystem.js

@@ -0,0 +1,327 @@
+/**
+* Head tracking smoothing factor (0-1)
+* Lower values = smoother but slower head tracking
+* 0.1 = smooth, natural head movement
+*
+* @korean 머리추적부드러움
+*/
+var HEAD_TRACKING_SMOOTHING = .1;
+/**
+* Normalizes an angle to 0-360 degree range
+*
+* @param angle - Angle in degrees
+* @returns Normalized angle in 0-360 range
+*
+* @example
+* ```typescript
+* normalizeAngle(370); // Returns 10
+* normalizeAngle(-30); // Returns 330
+* ```
+*
+* @public
+* @korean 각도정규화
+*/
+function normalizeAngle(angle) {
+	let normalized = angle % 360;
+	if (normalized < 0) normalized += 360;
+	return normalized === 0 ? 0 : normalized;
+}
+/**
+* Calculates the shortest angular difference between two angles
+* Returns value in range [-180, 180]
+* - Positive = clockwise rotation
+* - Negative = counter-clockwise rotation
+*
+* @param from - Starting angle in degrees
+* @param to - Target angle in degrees
+* @returns Shortest angular difference in degrees
+*
+* @example
+* ```typescript
+* calculateAngleDifference(10, 350); // Returns -20 (turn left)
+* calculateAngleDifference(350, 10); // Returns 20 (turn right)
+* calculateAngleDifference(0, 180); // Returns 180
+* ```
+*
+* @public
+* @korean 각도차이계산
+*/
+function calculateAngleDifference(from, to) {
+	const fromNorm = normalizeAngle(from);
+	let diff = normalizeAngle(to) - fromNorm;
+	if (diff > 180) diff -= 360;
+	else if (diff < -180) diff += 360;
+	return diff;
+}
+/**
+* Calculates angle from one position to another
+* Returns angle in degrees (0-360)
+* - 0° = pointing right (+X)
+* - 90° = pointing down (+Z)
+* - 180° = pointing left (-X)
+* - 270° = pointing up (-Z)
+*
+* @param from - Starting position
+* @param to - Target position
+* @returns Angle in degrees
+*
+* @example
+* ```typescript
+* calculateAngleToTarget({ x: 0, y: 0 }, { x: 1, y: 0 }); // Returns 0° (right)
+* calculateAngleToTarget({ x: 0, y: 0 }, { x: 0, y: 1 }); // Returns 90° (down)
+* ```
+*
+* @public
+* @korean 목표각도계산
+*/
+function calculateAngleToTarget(from, to) {
+	const dx = to.x - from.x;
+	const dz = to.y - from.y;
+	return normalizeAngle(Math.atan2(dz, dx) * (180 / Math.PI));
+}
+/**
+* Linear interpolation between two values
+*
+* @param start - Start value
+* @param end - End value
+* @param t - Interpolation factor (0-1)
+* @returns Interpolated value
+*
+* @private
+* @korean 선형보간
+*/
+function lerp(start, end, t) {
+	return start + (end - start) * t;
+}
+/**
+* Creates default body facing state
+*
+* @param initialAngle - Initial facing angle in degrees (default: 0)
+* @returns Default BodyFacing state
+*
+* @public
+* @korean 기본몸향하기생성
+*/
+function createDefaultBodyFacing(initialAngle = 0) {
+	const initialRadians = initialAngle * Math.PI / 180;
+	return {
+		currentAngle: normalizeAngle(initialAngle),
+		targetAngle: normalizeAngle(initialAngle),
+		rotationSpeed: 45,
+		headAngleOffset: 0,
+		isLocked: false,
+		isTurning: false,
+		torsoRotation: 0,
+		hipRotation: initialRadians
+	};
+}
+/**
+* Updates body facing direction with smooth rotation
+*
+* Performs smooth rotation toward target angle at specified speed.
+* Handles:
+* - Rotation locking during attacks
+* - 180° turn animation triggering
+* - Head tracking with independent offset
+* - Smooth interpolation at 45°/sec
+*
+* @param facing - Current body facing state
+* @param targetAngle - Desired facing angle in degrees
+* @param deltaTime - Time elapsed since last update in seconds
+* @param currentTime - Current timestamp in milliseconds
+* @returns Updated body facing state
+*
+* @example
+* ```typescript
+* const facing = createDefaultBodyFacing(0);
+* const updated = updateBodyFacing(facing, 90, 0.016, Date.now());
+* // Rotates ~0.72° toward 90° (45°/sec * 0.016s)
+* ```
+*
+* @public
+* @korean 몸향하기업데이트
+*/
+function updateBodyFacing(facing, targetAngle, deltaTime, currentTime) {
+	if (facing.isLocked) return facing;
+	if (facing.isTurning && facing.turnStartTime) {
+		if (currentTime - facing.turnStartTime >= 200) return {
+			...facing,
+			currentAngle: normalizeAngle(targetAngle),
+			targetAngle: normalizeAngle(targetAngle),
+			headAngleOffset: 0,
+			isTurning: false,
+			turnDirection: void 0,
+			turnStartTime: void 0
+		};
+		return {
+			...facing,
+			targetAngle: normalizeAngle(targetAngle)
+		};
+	}
+	const angleDiff = calculateAngleDifference(facing.currentAngle, targetAngle);
+	if (Math.abs(angleDiff) > 90 && !facing.isTurning) return {
+		...facing,
+		targetAngle: normalizeAngle(targetAngle),
+		isTurning: true,
+		turnDirection: angleDiff > 0 ? "right" : "left",
+		turnStartTime: currentTime
+	};
+	const maxRotation = facing.rotationSpeed * deltaTime;
+	const rotation = Math.sign(angleDiff) * Math.min(Math.abs(angleDiff), maxRotation);
+	const newCurrentAngle = normalizeAngle(facing.currentAngle + rotation);
+	const remainingDiff = calculateAngleDifference(newCurrentAngle, targetAngle);
+	const targetHeadOffset = Math.max(-45, Math.min(45, remainingDiff));
+	const newHeadOffset = lerp(facing.headAngleOffset, targetHeadOffset, HEAD_TRACKING_SMOOTHING);
+	return {
+		...facing,
+		currentAngle: newCurrentAngle,
+		targetAngle: normalizeAngle(targetAngle),
+		headAngleOffset: newHeadOffset
+	};
+}
+/**
+* Updates facing direction to point toward opponent
+*
+* Calculates target angle based on opponent position and updates
+* body facing state with smooth rotation.
+*
+* @param facing - Current body facing state
+* @param playerPosition - Player's current position
+* @param opponentPosition - Opponent's current position
+* @param deltaTime - Time elapsed since last update in seconds
+* @param currentTime - Current timestamp in milliseconds
+* @returns Updated body facing state
+*
+* @example
+* ```typescript
+* const updated = updateFacingTowardOpponent(
+*   facing,
+*   { x: 100, y: 200 },
+*   { x: 300, y: 200 },
+*   0.016,
+*   Date.now()
+* );
+* // Faces toward opponent (pointing right in this case)
+* ```
+*
+* @public
+* @korean 상대방향하기업데이트
+*/
+function updateFacingTowardOpponent(facing, playerPosition, opponentPosition, deltaTime, currentTime) {
+	return updateBodyFacing(facing, calculateAngleToTarget(playerPosition, opponentPosition), deltaTime, currentTime);
+}
+/**
+* Locks facing direction (during attacks/defends)
+*
+* Prevents rotation while attack or defend animation is playing.
+* Maintains current facing angle.
+*
+* @param facing - Current body facing state
+* @returns Updated body facing state with lock enabled
+*
+* @public
+* @korean 회전잠금
+*/
+function lockFacing(facing) {
+	return {
+		...facing,
+		isLocked: true
+	};
+}
+/**
+* Unlocks facing direction (after attacks/defends complete)
+*
+* Allows rotation to resume after attack or defend animation completes.
+*
+* @param facing - Current body facing state
+* @returns Updated body facing state with lock disabled
+*
+* @public
+* @korean 회전잠금해제
+*/
+function unlockFacing(facing) {
+	return {
+		...facing,
+		isLocked: false
+	};
+}
+/**
+* Gets head angle in radians including offset
+* Combines torso rotation with head tracking offset
+*
+* @param facing - Current body facing state
+* @returns Head rotation angle in radians
+*
+* @public
+* @korean 머리각도라디안
+*/
+function getHeadAngleRadians(facing) {
+	return (facing.currentAngle + facing.headAngleOffset) * Math.PI / 180;
+}
+/**
+* Body Facing System singleton for managing character rotation
+*
+* Provides centralized system for body facing calculations and updates.
+*
+* @public
+* @korean 몸향하기시스템
+*/
+var BodyFacingSystem = class {
+	/**
+	* Creates default body facing state for a new player
+	*
+	* @param initialAngle - Initial facing angle in degrees
+	* @returns Default body facing state
+	*
+	* @public
+	* @korean 기본상태생성
+	*/
+	createDefaultState(initialAngle = 0) {
+		return createDefaultBodyFacing(initialAngle);
+	}
+	/**
+	* Updates body facing with opponent tracking
+	*
+	* @param facing - Current body facing state
+	* @param playerPosition - Player position
+	* @param opponentPosition - Opponent position
+	* @param deltaTime - Delta time in seconds
+	* @param currentTime - Current timestamp
+	* @returns Updated body facing state
+	*
+	* @public
+	* @korean 업데이트
+	*/
+	update(facing, playerPosition, opponentPosition, deltaTime, currentTime) {
+		return updateFacingTowardOpponent(facing, playerPosition, opponentPosition, deltaTime, currentTime);
+	}
+	/**
+	* Locks facing during attacks
+	*
+	* @param facing - Current body facing state
+	* @returns Updated state with lock
+	*
+	* @public
+	* @korean 잠금
+	*/
+	lock(facing) {
+		return lockFacing(facing);
+	}
+	/**
+	* Unlocks facing after attacks
+	*
+	* @param facing - Current body facing state
+	* @returns Updated state without lock
+	*
+	* @public
+	* @korean 잠금해제
+	*/
+	unlock(facing) {
+		return unlockFacing(facing);
+	}
+};
+new BodyFacingSystem();
+//#endregion
+export { BodyFacingSystem, HEAD_TRACKING_SMOOTHING, calculateAngleDifference, calculateAngleToTarget, createDefaultBodyFacing, getHeadAngleRadians, lockFacing, normalizeAngle, unlockFacing, updateBodyFacing, updateFacingTowardOpponent };
+
+//# sourceMappingURL=BodyFacingSystem.js.map

package/lib/systems/animation/systems/BodyFacingSystem.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"BodyFacingSystem.js","names":[],"sources":["../../../../src/systems/animation/systems/BodyFacingSystem.ts"],"sourcesContent":["/**\n * Body Facing Direction System for Black Trigram\n *\n * Manages automatic character rotation to face opponent with:\n * - Smooth torso rotation at 45°/sec (±90° range)\n * - Independent head tracking (±45° range)\n * - 180° turn animations for repositioning\n * - Facing lock during attack/defend animations\n *\n * Korean terminology:\n * - 정면향하기 (Jeongmyeon Hyanghagi) - Face forward\n * - 몸회전 (Mom Hoejeon) - Body rotation\n * - 머리추적 (Meori Chujok) - Head tracking\n * - 180도회전 (180-do Hoejeon) - 180-degree turn\n *\n * @module systems/animation/BodyFacingSystem\n * @category Animation System\n * @korean 몸향하기시스템\n */\n\nimport { Position } from \"@/types\";\nimport type { BodyFacing } from \"../core/types\";\n\n/**\n * Default rotation speed in degrees per second\n * 45°/sec provides smooth, realistic rotation\n *\n * @korean 기본회전속도\n */\nexport const DEFAULT_ROTATION_SPEED = 45;\n\n/**\n * Maximum torso rotation range in degrees\n * Torso can rotate ±90° from facing direction\n *\n * @korean 최대몸통회전\n */\nexport const MAX_TORSO_ROTATION = 90;\n\n/**\n * Maximum head rotation offset in degrees\n * Head can track independently ±45° from torso\n *\n * @korean 최대머리회전\n */\nexport const MAX_HEAD_ROTATION = 45;\n\n/**\n * Threshold angle for triggering 180° turn animation\n * If angle difference exceeds this, play full turn animation\n *\n * @korean 180도회전기준각도\n */\nexport const TURN_THRESHOLD_ANGLE = 90;\n\n/**\n * Duration of 180° turn animation in milliseconds\n * 12 frames at 60fps = 200ms\n *\n * @korean 회전애니메이션시간\n */\nexport const TURN_ANIMATION_DURATION = 200;\n\n/**\n * Head tracking smoothing factor (0-1)\n * Lower values = smoother but slower head tracking\n * 0.1 = smooth, natural head movement\n *\n * @korean 머리추적부드러움\n */\nexport const HEAD_TRACKING_SMOOTHING = 0.1;\n\n/**\n * Normalizes an angle to 0-360 degree range\n *\n * @param angle - Angle in degrees\n * @returns Normalized angle in 0-360 range\n *\n * @example\n * ```typescript\n * normalizeAngle(370); // Returns 10\n * normalizeAngle(-30); // Returns 330\n * ```\n *\n * @public\n * @korean 각도정규화\n */\nexport function normalizeAngle(angle: number): number {\n  let normalized = angle % 360;\n  if (normalized < 0) {\n    normalized += 360;\n  }\n  // Handle -0 edge case (JavaScript quirk)\n  return normalized === 0 ? 0 : normalized;\n}\n\n/**\n * Calculates the shortest angular difference between two angles\n * Returns value in range [-180, 180]\n * - Positive = clockwise rotation\n * - Negative = counter-clockwise rotation\n *\n * @param from - Starting angle in degrees\n * @param to - Target angle in degrees\n * @returns Shortest angular difference in degrees\n *\n * @example\n * ```typescript\n * calculateAngleDifference(10, 350); // Returns -20 (turn left)\n * calculateAngleDifference(350, 10); // Returns 20 (turn right)\n * calculateAngleDifference(0, 180); // Returns 180\n * ```\n *\n * @public\n * @korean 각도차이계산\n */\nexport function calculateAngleDifference(from: number, to: number): number {\n  const fromNorm = normalizeAngle(from);\n  const toNorm = normalizeAngle(to);\n\n  let diff = toNorm - fromNorm;\n\n  // Find shortest path\n  if (diff > 180) {\n    diff -= 360;\n  } else if (diff < -180) {\n    diff += 360;\n  }\n\n  return diff;\n}\n\n/**\n * Calculates angle from one position to another\n * Returns angle in degrees (0-360)\n * - 0° = pointing right (+X)\n * - 90° = pointing down (+Z)\n * - 180° = pointing left (-X)\n * - 270° = pointing up (-Z)\n *\n * @param from - Starting position\n * @param to - Target position\n * @returns Angle in degrees\n *\n * @example\n * ```typescript\n * calculateAngleToTarget({ x: 0, y: 0 }, { x: 1, y: 0 }); // Returns 0° (right)\n * calculateAngleToTarget({ x: 0, y: 0 }, { x: 0, y: 1 }); // Returns 90° (down)\n * ```\n *\n * @public\n * @korean 목표각도계산\n */\nexport function calculateAngleToTarget(from: Position, to: Position): number {\n  const dx = to.x - from.x;\n  const dz = to.y - from.y; // Position.y is Z coordinate in 2D top-down\n\n  // atan2 returns angle in radians, convert to degrees\n  // atan2(y, x) where y is forward/back (Z), x is left/right (X)\n  const angle = Math.atan2(dz, dx) * (180 / Math.PI);\n\n  return normalizeAngle(angle);\n}\n\n/**\n * Linear interpolation between two values\n *\n * @param start - Start value\n * @param end - End value\n * @param t - Interpolation factor (0-1)\n * @returns Interpolated value\n *\n * @private\n * @korean 선형보간\n */\nfunction lerp(start: number, end: number, t: number): number {\n  return start + (end - start) * t;\n}\n\n/**\n * Creates default body facing state\n *\n * @param initialAngle - Initial facing angle in degrees (default: 0)\n * @returns Default BodyFacing state\n *\n * @public\n * @korean 기본몸향하기생성\n */\nexport function createDefaultBodyFacing(initialAngle = 0): BodyFacing {\n  const initialRadians = (initialAngle * Math.PI) / 180;\n  return {\n    currentAngle: normalizeAngle(initialAngle),\n    targetAngle: normalizeAngle(initialAngle),\n    rotationSpeed: DEFAULT_ROTATION_SPEED,\n    headAngleOffset: 0,\n    isLocked: false,\n    isTurning: false,\n    torsoRotation: 0, // No initial torso twist\n    hipRotation: initialRadians, // Hips aligned with current angle\n  };\n}\n\n/**\n * Updates body facing direction with smooth rotation\n *\n * Performs smooth rotation toward target angle at specified speed.\n * Handles:\n * - Rotation locking during attacks\n * - 180° turn animation triggering\n * - Head tracking with independent offset\n * - Smooth interpolation at 45°/sec\n *\n * @param facing - Current body facing state\n * @param targetAngle - Desired facing angle in degrees\n * @param deltaTime - Time elapsed since last update in seconds\n * @param currentTime - Current timestamp in milliseconds\n * @returns Updated body facing state\n *\n * @example\n * ```typescript\n * const facing = createDefaultBodyFacing(0);\n * const updated = updateBodyFacing(facing, 90, 0.016, Date.now());\n * // Rotates ~0.72° toward 90° (45°/sec * 0.016s)\n * ```\n *\n * @public\n * @korean 몸향하기업데이트\n */\nexport function updateBodyFacing(\n  facing: BodyFacing,\n  targetAngle: number,\n  deltaTime: number,\n  currentTime: number\n): BodyFacing {\n  // If locked, no rotation allowed\n  if (facing.isLocked) {\n    return facing;\n  }\n\n  // Check if 180° turn animation is in progress\n  if (facing.isTurning && facing.turnStartTime) {\n    const elapsed = currentTime - facing.turnStartTime;\n\n    if (elapsed >= TURN_ANIMATION_DURATION) {\n      // Turn animation complete - snap to target angle\n      return {\n        ...facing,\n        currentAngle: normalizeAngle(targetAngle),\n        targetAngle: normalizeAngle(targetAngle),\n        headAngleOffset: 0,\n        isTurning: false,\n        turnDirection: undefined,\n        turnStartTime: undefined,\n      };\n    }\n\n    // Still turning - don't update angle yet\n    return {\n      ...facing,\n      targetAngle: normalizeAngle(targetAngle),\n    };\n  }\n\n  // Calculate angle difference\n  const angleDiff = calculateAngleDifference(facing.currentAngle, targetAngle);\n\n  // Check if 180° turn is needed\n  if (Math.abs(angleDiff) > TURN_THRESHOLD_ANGLE && !facing.isTurning) {\n    // Trigger 180° turn animation\n    return {\n      ...facing,\n      targetAngle: normalizeAngle(targetAngle),\n      isTurning: true,\n      turnDirection: angleDiff > 0 ? \"right\" : \"left\",\n      turnStartTime: currentTime,\n    };\n  }\n\n  // Calculate maximum rotation for this frame\n  const maxRotation = facing.rotationSpeed * deltaTime;\n\n  // Calculate actual rotation (limited by max rotation)\n  const rotation =\n    Math.sign(angleDiff) * Math.min(Math.abs(angleDiff), maxRotation);\n\n  // Update current angle\n  const newCurrentAngle = normalizeAngle(facing.currentAngle + rotation);\n\n  // Update head tracking (±45° range independent of torso)\n  // Head smoothly tracks toward target within allowed range\n  const remainingDiff = calculateAngleDifference(newCurrentAngle, targetAngle);\n  const targetHeadOffset = Math.max(\n    -MAX_HEAD_ROTATION,\n    Math.min(MAX_HEAD_ROTATION, remainingDiff)\n  );\n\n  const newHeadOffset = lerp(\n    facing.headAngleOffset,\n    targetHeadOffset,\n    HEAD_TRACKING_SMOOTHING\n  );\n\n  return {\n    ...facing,\n    currentAngle: newCurrentAngle,\n    targetAngle: normalizeAngle(targetAngle),\n    headAngleOffset: newHeadOffset,\n  };\n}\n\n/**\n * Updates facing direction to point toward opponent\n *\n * Calculates target angle based on opponent position and updates\n * body facing state with smooth rotation.\n *\n * @param facing - Current body facing state\n * @param playerPosition - Player's current position\n * @param opponentPosition - Opponent's current position\n * @param deltaTime - Time elapsed since last update in seconds\n * @param currentTime - Current timestamp in milliseconds\n * @returns Updated body facing state\n *\n * @example\n * ```typescript\n * const updated = updateFacingTowardOpponent(\n *   facing,\n *   { x: 100, y: 200 },\n *   { x: 300, y: 200 },\n *   0.016,\n *   Date.now()\n * );\n * // Faces toward opponent (pointing right in this case)\n * ```\n *\n * @public\n * @korean 상대방향하기업데이트\n */\nexport function updateFacingTowardOpponent(\n  facing: BodyFacing,\n  playerPosition: Position,\n  opponentPosition: Position,\n  deltaTime: number,\n  currentTime: number\n): BodyFacing {\n  const targetAngle = calculateAngleToTarget(playerPosition, opponentPosition);\n  return updateBodyFacing(facing, targetAngle, deltaTime, currentTime);\n}\n\n/**\n * Locks facing direction (during attacks/defends)\n *\n * Prevents rotation while attack or defend animation is playing.\n * Maintains current facing angle.\n *\n * @param facing - Current body facing state\n * @returns Updated body facing state with lock enabled\n *\n * @public\n * @korean 회전잠금\n */\nexport function lockFacing(facing: BodyFacing): BodyFacing {\n  return {\n    ...facing,\n    isLocked: true,\n  };\n}\n\n/**\n * Unlocks facing direction (after attacks/defends complete)\n *\n * Allows rotation to resume after attack or defend animation completes.\n *\n * @param facing - Current body facing state\n * @returns Updated body facing state with lock disabled\n *\n * @public\n * @korean 회전잠금해제\n */\nexport function unlockFacing(facing: BodyFacing): BodyFacing {\n  return {\n    ...facing,\n    isLocked: false,\n  };\n}\n\n/**\n * Checks if character is currently turning (180° animation)\n *\n * @param facing - Current body facing state\n * @returns True if 180° turn animation is in progress\n *\n * @public\n * @korean 회전중확인\n */\nexport function isTurning(facing: BodyFacing): boolean {\n  return facing.isTurning;\n}\n\n/**\n * Gets current facing angle in radians\n * Useful for Three.js rotation (expects radians)\n *\n * @param facing - Current body facing state\n * @returns Current facing angle in radians\n *\n * @public\n * @korean 라디안각도\n */\nexport function getFacingAngleRadians(facing: BodyFacing): number {\n  return (facing.currentAngle * Math.PI) / 180;\n}\n\n/**\n * Gets head angle in radians including offset\n * Combines torso rotation with head tracking offset\n *\n * @param facing - Current body facing state\n * @returns Head rotation angle in radians\n *\n * @public\n * @korean 머리각도라디안\n */\nexport function getHeadAngleRadians(facing: BodyFacing): number {\n  const totalAngle = facing.currentAngle + facing.headAngleOffset;\n  return (totalAngle * Math.PI) / 180;\n}\n\n/**\n * Gets torso rotation in radians\n * Returns the torso rotation relative to hips\n *\n * @param facing - Current body facing state\n * @returns Torso rotation in radians (defaults to 0 if not set)\n *\n * @public\n * @korean 허리회전라디안\n */\nexport function getTorsoRotationRadians(facing: BodyFacing): number {\n  return facing.torsoRotation ?? 0;\n}\n\n/**\n * Gets hip rotation in radians\n * Returns the hip/pelvis base rotation\n *\n * @param facing - Current body facing state\n * @returns Hip rotation in radians\n *\n * @public\n * @korean 골반회전라디안\n */\nexport function getHipRotationRadians(facing: BodyFacing): number {\n  return facing.hipRotation ?? getFacingAngleRadians(facing);\n}\n\n/**\n * Body Facing System singleton for managing character rotation\n *\n * Provides centralized system for body facing calculations and updates.\n *\n * @public\n * @korean 몸향하기시스템\n */\nexport class BodyFacingSystem {\n  /**\n   * Creates default body facing state for a new player\n   *\n   * @param initialAngle - Initial facing angle in degrees\n   * @returns Default body facing state\n   *\n   * @public\n   * @korean 기본상태생성\n   */\n  createDefaultState(initialAngle = 0): BodyFacing {\n    return createDefaultBodyFacing(initialAngle);\n  }\n\n  /**\n   * Updates body facing with opponent tracking\n   *\n   * @param facing - Current body facing state\n   * @param playerPosition - Player position\n   * @param opponentPosition - Opponent position\n   * @param deltaTime - Delta time in seconds\n   * @param currentTime - Current timestamp\n   * @returns Updated body facing state\n   *\n   * @public\n   * @korean 업데이트\n   */\n  update(\n    facing: BodyFacing,\n    playerPosition: Position,\n    opponentPosition: Position,\n    deltaTime: number,\n    currentTime: number\n  ): BodyFacing {\n    return updateFacingTowardOpponent(\n      facing,\n      playerPosition,\n      opponentPosition,\n      deltaTime,\n      currentTime\n    );\n  }\n\n  /**\n   * Locks facing during attacks\n   *\n   * @param facing - Current body facing state\n   * @returns Updated state with lock\n   *\n   * @public\n   * @korean 잠금\n   */\n  lock(facing: BodyFacing): BodyFacing {\n    return lockFacing(facing);\n  }\n\n  /**\n   * Unlocks facing after attacks\n   *\n   * @param facing - Current body facing state\n   * @returns Updated state without lock\n   *\n   * @public\n   * @korean 잠금해제\n   */\n  unlock(facing: BodyFacing): BodyFacing {\n    return unlockFacing(facing);\n  }\n}\n\n/**\n * Default body facing system instance\n *\n * @public\n * @korean 기본몸향하기시스템\n */\nexport const bodyFacingSystem = new BodyFacingSystem();\n\nexport default bodyFacingSystem;\n"],"mappings":"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"}

package/lib/systems/animation/systems/FacialExpressions.d.ts

@@ -0,0 +1,167 @@
+/**
+ * Facial expression system for realistic combat emotion
+ *
+ * Manages facial expression state based on combat conditions:
+ * - Health, stamina, pain, consciousness levels
+ * - Recent combat events (hits taken/landed)
+ * - Dynamic expression transitions
+ *
+ * @module systems/animation/FacialExpressions
+ * @category Animation System
+ * @korean 얼굴표정시스템
+ */
+import { FacialExpression, type ExpressionState, type FacialDamageState } from "../../../types/facial";
+/**
+ * Expression transition configuration
+ *
+ * @public
+ * @korean 표정전환설정
+ */
+export interface ExpressionTransitionConfig {
+    /** Default transition time in seconds */
+    readonly defaultTransitionTime: number;
+    /** Quick transition time for immediate reactions */
+    readonly quickTransitionTime: number;
+    /** Slow transition time for gradual changes */
+    readonly slowTransitionTime: number;
+}
+/**
+ * Default expression transition configuration
+ *
+ * @public
+ * @korean 기본표정전환설정
+ */
+export declare const DEFAULT_TRANSITION_CONFIG: ExpressionTransitionConfig;
+/**
+ * Get facial expression based on current combat state
+ *
+ * Evaluates fighter's physical and mental state to determine appropriate
+ * facial expression. Priority order:
+ * 1. Defeated (unconscious)
+ * 2. Pained (just hit)
+ * 3. Exhausted (low stamina)
+ * 4. Victorious (just landed hit)
+ * 5. Focused (high resources)
+ * 6. Neutral (default)
+ *
+ * @param health - Current health (0-100)
+ * @param maxHealth - Maximum health
+ * @param stamina - Current stamina (0-100)
+ * @param pain - Pain level (0-100)
+ * @param consciousness - Consciousness level (0-100)
+ * @param justHit - Whether fighter was just hit
+ * @param justLanded - Whether fighter just landed a hit
+ * @returns Appropriate facial expression for combat state
+ *
+ * @example
+ * ```typescript
+ * const expression = getExpressionFromCombatState(
+ *   85,  // health
+ *   100, // maxHealth
+ *   60,  // stamina
+ *   20,  // pain
+ *   100, // consciousness
+ *   false, // justHit
+ *   true   // justLanded
+ * );
+ * // Returns: FacialExpression.VICTORIOUS
+ * ```
+ *
+ * @public
+ * @korean 전투상태로부터표정가져오기
+ */
+export declare const getExpressionFromCombatState: (health: number, maxHealth: number, stamina: number, _pain: number, // Reserved for future intensity calculation
+consciousness: number, justHit: boolean, justLanded: boolean) => FacialExpression;
+/**
+ * Create new expression state with transition
+ *
+ * @param currentState - Current expression state
+ * @param newExpression - New expression to transition to
+ * @param transitionTime - Time to transition (seconds)
+ * @returns New expression state with transition initialized
+ *
+ * @public
+ * @korean 새표정상태생성
+ */
+export declare const createExpressionTransition: (currentState: ExpressionState, newExpression: FacialExpression, transitionTime?: number) => ExpressionState;
+/**
+ * Update expression state during transition
+ *
+ * @param state - Current expression state
+ * @param deltaTime - Time since last update (seconds)
+ * @returns Updated expression state with transition progress
+ *
+ * @public
+ * @korean 표정상태업데이트
+ */
+export declare const updateExpressionState: (state: ExpressionState, deltaTime: number) => ExpressionState;
+/**
+ * Calculate facial damage from hit
+ *
+ * Updates facial damage state based on hit location and damage amount.
+ * Different facial regions accumulate damage independently.
+ *
+ * @param currentDamage - Current facial damage state
+ * @param hitLocation - Location of hit on face ("left_eye", "right_eye", "mouth", "nose", etc.)
+ * @param damageAmount - Amount of damage dealt (0-100)
+ * @returns Updated facial damage state
+ *
+ * @example
+ * ```typescript
+ * const damage = calculateFacialDamage(
+ *   DEFAULT_FACIAL_DAMAGE,
+ *   "left_eye",
+ *   25
+ * );
+ * // Returns damage state with left eye swelling increased
+ * ```
+ *
+ * @public
+ * @korean 얼굴손상계산
+ */
+export declare const calculateFacialDamage: (currentDamage: FacialDamageState, hitLocation: string, damageAmount: number) => FacialDamageState;
+/**
+ * Reset facial damage (for new round or healing)
+ *
+ * @param partialReset - If true, only reduces damage by percentage (healing)
+ * @param resetPercentage - Percentage to reduce damage (0-1)
+ * @returns Fresh facial damage state
+ *
+ * @public
+ * @korean 얼굴손상초기화
+ */
+export declare const resetFacialDamage: (currentDamage: FacialDamageState, partialReset?: boolean, resetPercentage?: number) => FacialDamageState;
+/**
+ * Get expression intensity based on combat state
+ *
+ * Expression intensity affects degree of facial movement.
+ * Higher pain/damage = more intense expressions.
+ *
+ * @param expression - Current facial expression
+ * @param pain - Pain level (0-100)
+ * @param stamina - Stamina level (0-100)
+ * @returns Expression intensity (0-1)
+ *
+ * @public
+ * @korean 표정강도가져오기
+ */
+export declare const getExpressionIntensity: (expression: FacialExpression, pain: number, stamina: number) => number;
+/**
+ * Create default expression state
+ *
+ * @returns Default neutral expression state
+ *
+ * @public
+ * @korean 기본표정상태생성
+ */
+export declare const createDefaultExpressionState: () => ExpressionState;
+/**
+ * Create default facial damage state
+ *
+ * @returns Default facial damage state with no damage
+ *
+ * @public
+ * @korean 기본얼굴손상생성
+ */
+export declare const createDefaultFacialDamage: () => FacialDamageState;
+//# sourceMappingURL=FacialExpressions.d.ts.map

package/lib/systems/animation/systems/FacialExpressions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FacialExpressions.d.ts","sourceRoot":"","sources":["../../../../src/systems/animation/systems/FacialExpressions.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EACL,gBAAgB,EAChB,KAAK,eAAe,EACpB,KAAK,iBAAiB,EAGvB,MAAM,gBAAgB,CAAC;AAExB;;;;;GAKG;AACH,MAAM,WAAW,0BAA0B;IACzC,yCAAyC;IACzC,QAAQ,CAAC,qBAAqB,EAAE,MAAM,CAAC;IAEvC,oDAAoD;IACpD,QAAQ,CAAC,mBAAmB,EAAE,MAAM,CAAC;IAErC,+CAA+C;IAC/C,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAC;CACrC;AAED;;;;;GAKG;AACH,eAAO,MAAM,yBAAyB,EAAE,0BAIvC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,eAAO,MAAM,4BAA4B,GACvC,QAAQ,MAAM,EACd,WAAW,MAAM,EACjB,SAAS,MAAM,EACf,OAAO,MAAM,EAAE,4CAA4C;AAC3D,eAAe,MAAM,EACrB,SAAS,OAAO,EAChB,YAAY,OAAO,KAClB,gBA6BF,CAAC;AAEF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,0BAA0B,GACrC,cAAc,eAAe,EAC7B,eAAe,gBAAgB,EAC/B,iBAAiB,MAAM,KACtB,eAaF,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,qBAAqB,GAChC,OAAO,eAAe,EACtB,WAAW,MAAM,KAChB,eA0BF,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,qBAAqB,GAChC,eAAe,iBAAiB,EAChC,aAAa,MAAM,EACnB,cAAc,MAAM,KACnB,iBA2FF,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,iBAAiB,GAC5B,eAAe,iBAAiB,EAChC,sBAAoB,EACpB,wBAAqB,KACpB,iBAkBF,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,sBAAsB,GACjC,YAAY,gBAAgB,EAC5B,MAAM,MAAM,EACZ,SAAS,MAAM,KACd,MA2BF,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,4BAA4B,QAAO,eAE/C,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,yBAAyB,QAAO,iBAE5C,CAAC"}

package/lib/systems/animation/systems/FacialExpressions.js

@@ -0,0 +1,76 @@
+import { DEFAULT_FACIAL_DAMAGE, FacialExpression } from "../../../types/facial.js";
+//#region src/systems/animation/systems/FacialExpressions.ts
+/**
+* Facial expression system for realistic combat emotion
+* 
+* Manages facial expression state based on combat conditions:
+* - Health, stamina, pain, consciousness levels
+* - Recent combat events (hits taken/landed)
+* - Dynamic expression transitions
+* 
+* @module systems/animation/FacialExpressions
+* @category Animation System
+* @korean 얼굴표정시스템
+*/
+/**
+* Get facial expression based on current combat state
+* 
+* Evaluates fighter's physical and mental state to determine appropriate
+* facial expression. Priority order:
+* 1. Defeated (unconscious)
+* 2. Pained (just hit)
+* 3. Exhausted (low stamina)
+* 4. Victorious (just landed hit)
+* 5. Focused (high resources)
+* 6. Neutral (default)
+* 
+* @param health - Current health (0-100)
+* @param maxHealth - Maximum health
+* @param stamina - Current stamina (0-100)
+* @param pain - Pain level (0-100)
+* @param consciousness - Consciousness level (0-100)
+* @param justHit - Whether fighter was just hit
+* @param justLanded - Whether fighter just landed a hit
+* @returns Appropriate facial expression for combat state
+* 
+* @example
+* ```typescript
+* const expression = getExpressionFromCombatState(
+*   85,  // health
+*   100, // maxHealth
+*   60,  // stamina
+*   20,  // pain
+*   100, // consciousness
+*   false, // justHit
+*   true   // justLanded
+* );
+* // Returns: FacialExpression.VICTORIOUS
+* ```
+* 
+* @public
+* @korean 전투상태로부터표정가져오기
+*/
+var getExpressionFromCombatState = (health, maxHealth, stamina, _pain, consciousness, justHit, justLanded) => {
+	if (consciousness < 20) return FacialExpression.DEFEATED;
+	if (justHit) return FacialExpression.PAINED;
+	if (stamina < 30) return FacialExpression.EXHAUSTED;
+	if (justLanded) return FacialExpression.VICTORIOUS;
+	const healthPercentage = health / maxHealth * 100;
+	if (stamina > 70 && healthPercentage > 60) return FacialExpression.FOCUSED;
+	return FacialExpression.NEUTRAL;
+};
+/**
+* Create default facial damage state
+* 
+* @returns Default facial damage state with no damage
+* 
+* @public
+* @korean 기본얼굴손상생성
+*/
+var createDefaultFacialDamage = () => {
+	return { ...DEFAULT_FACIAL_DAMAGE };
+};
+//#endregion
+export { createDefaultFacialDamage, getExpressionFromCombatState };
+
+//# sourceMappingURL=FacialExpressions.js.map

package/lib/systems/animation/systems/FacialExpressions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"FacialExpressions.js","names":[],"sources":["../../../../src/systems/animation/systems/FacialExpressions.ts"],"sourcesContent":["/**\n * Facial expression system for realistic combat emotion\n * \n * Manages facial expression state based on combat conditions:\n * - Health, stamina, pain, consciousness levels\n * - Recent combat events (hits taken/landed)\n * - Dynamic expression transitions\n * \n * @module systems/animation/FacialExpressions\n * @category Animation System\n * @korean 얼굴표정시스템\n */\n\nimport {\n  FacialExpression,\n  type ExpressionState,\n  type FacialDamageState,\n  DEFAULT_FACIAL_DAMAGE,\n  DEFAULT_EXPRESSION_STATE,\n} from \"@/types/facial\";\n\n/**\n * Expression transition configuration\n * \n * @public\n * @korean 표정전환설정\n */\nexport interface ExpressionTransitionConfig {\n  /** Default transition time in seconds */\n  readonly defaultTransitionTime: number;\n  \n  /** Quick transition time for immediate reactions */\n  readonly quickTransitionTime: number;\n  \n  /** Slow transition time for gradual changes */\n  readonly slowTransitionTime: number;\n}\n\n/**\n * Default expression transition configuration\n * \n * @public\n * @korean 기본표정전환설정\n */\nexport const DEFAULT_TRANSITION_CONFIG: ExpressionTransitionConfig = {\n  defaultTransitionTime: 0.2,\n  quickTransitionTime: 0.1,\n  slowTransitionTime: 0.5,\n};\n\n/**\n * Get facial expression based on current combat state\n * \n * Evaluates fighter's physical and mental state to determine appropriate\n * facial expression. Priority order:\n * 1. Defeated (unconscious)\n * 2. Pained (just hit)\n * 3. Exhausted (low stamina)\n * 4. Victorious (just landed hit)\n * 5. Focused (high resources)\n * 6. Neutral (default)\n * \n * @param health - Current health (0-100)\n * @param maxHealth - Maximum health\n * @param stamina - Current stamina (0-100)\n * @param pain - Pain level (0-100)\n * @param consciousness - Consciousness level (0-100)\n * @param justHit - Whether fighter was just hit\n * @param justLanded - Whether fighter just landed a hit\n * @returns Appropriate facial expression for combat state\n * \n * @example\n * ```typescript\n * const expression = getExpressionFromCombatState(\n *   85,  // health\n *   100, // maxHealth\n *   60,  // stamina\n *   20,  // pain\n *   100, // consciousness\n *   false, // justHit\n *   true   // justLanded\n * );\n * // Returns: FacialExpression.VICTORIOUS\n * ```\n * \n * @public\n * @korean 전투상태로부터표정가져오기\n */\nexport const getExpressionFromCombatState = (\n  health: number,\n  maxHealth: number,\n  stamina: number,\n  _pain: number, // Reserved for future intensity calculation\n  consciousness: number,\n  justHit: boolean,\n  justLanded: boolean\n): FacialExpression => {\n  // Knocked out\n  if (consciousness < 20) {\n    return FacialExpression.DEFEATED;\n  }\n\n  // Just got hit (always show immediate reaction; pain level can control intensity)\n  if (justHit) {\n    return FacialExpression.PAINED;\n  }\n\n  // Low stamina (exhausted)\n  if (stamina < 30) {\n    return FacialExpression.EXHAUSTED;\n  }\n\n  // Just landed a hit (brief satisfaction)\n  if (justLanded) {\n    return FacialExpression.VICTORIOUS;\n  }\n\n  // High focus (ready to fight)\n  const healthPercentage = (health / maxHealth) * 100;\n  if (stamina > 70 && healthPercentage > 60) {\n    return FacialExpression.FOCUSED;\n  }\n\n  // Default calm state\n  return FacialExpression.NEUTRAL;\n};\n\n/**\n * Create new expression state with transition\n * \n * @param currentState - Current expression state\n * @param newExpression - New expression to transition to\n * @param transitionTime - Time to transition (seconds)\n * @returns New expression state with transition initialized\n * \n * @public\n * @korean 새표정상태생성\n */\nexport const createExpressionTransition = (\n  currentState: ExpressionState,\n  newExpression: FacialExpression,\n  transitionTime?: number\n): ExpressionState => {\n  // No transition needed if same expression\n  if (currentState.expression === newExpression) {\n    return currentState;\n  }\n\n  return {\n    expression: newExpression,\n    intensity: 1.0,\n    transitionTime: transitionTime ?? DEFAULT_TRANSITION_CONFIG.defaultTransitionTime,\n    previousExpression: currentState.expression,\n    transitionProgress: 0,\n  };\n};\n\n/**\n * Update expression state during transition\n * \n * @param state - Current expression state\n * @param deltaTime - Time since last update (seconds)\n * @returns Updated expression state with transition progress\n * \n * @public\n * @korean 표정상태업데이트\n */\nexport const updateExpressionState = (\n  state: ExpressionState,\n  deltaTime: number\n): ExpressionState => {\n  // No transition in progress\n  if (state.transitionProgress === undefined || state.transitionProgress >= 1.0) {\n    return state;\n  }\n\n  // Calculate new progress\n  const progressIncrement = deltaTime / state.transitionTime;\n  const newProgress = Math.min(state.transitionProgress + progressIncrement, 1.0);\n\n  // Transition complete\n  if (newProgress >= 1.0) {\n    return {\n      expression: state.expression,\n      intensity: state.intensity,\n      transitionTime: state.transitionTime,\n      previousExpression: undefined,\n      transitionProgress: undefined,\n    };\n  }\n\n  // Transition in progress\n  return {\n    ...state,\n    transitionProgress: newProgress,\n  };\n};\n\n/**\n * Calculate facial damage from hit\n * \n * Updates facial damage state based on hit location and damage amount.\n * Different facial regions accumulate damage independently.\n * \n * @param currentDamage - Current facial damage state\n * @param hitLocation - Location of hit on face (\"left_eye\", \"right_eye\", \"mouth\", \"nose\", etc.)\n * @param damageAmount - Amount of damage dealt (0-100)\n * @returns Updated facial damage state\n * \n * @example\n * ```typescript\n * const damage = calculateFacialDamage(\n *   DEFAULT_FACIAL_DAMAGE,\n *   \"left_eye\",\n *   25\n * );\n * // Returns damage state with left eye swelling increased\n * ```\n * \n * @public\n * @korean 얼굴손상계산\n */\nexport const calculateFacialDamage = (\n  currentDamage: FacialDamageState,\n  hitLocation: string,\n  damageAmount: number\n): FacialDamageState => {\n  const damageIntensity = Math.min(damageAmount / 100, 1.0);\n  const newDamage = { ...currentDamage };\n\n  switch (hitLocation.toLowerCase()) {\n    case \"left_eye\":\n    case \"temple_left\":\n      newDamage.leftEyeSwelling = Math.min(\n        currentDamage.leftEyeSwelling + damageIntensity * 0.3,\n        1.0\n      );\n      newDamage.leftCheekBruise = Math.min(\n        currentDamage.leftCheekBruise + damageIntensity * 0.2,\n        1.0\n      );\n      break;\n\n    case \"right_eye\":\n    case \"temple_right\":\n      newDamage.rightEyeSwelling = Math.min(\n        currentDamage.rightEyeSwelling + damageIntensity * 0.3,\n        1.0\n      );\n      newDamage.rightCheekBruise = Math.min(\n        currentDamage.rightCheekBruise + damageIntensity * 0.2,\n        1.0\n      );\n      break;\n\n    case \"mouth\":\n    case \"jaw\":\n    case \"chin\":\n      newDamage.mouthBleeding = Math.min(\n        currentDamage.mouthBleeding + damageIntensity * 0.4,\n        1.0\n      );\n      newDamage.jawBruise = Math.min(\n        currentDamage.jawBruise + damageIntensity * 0.3,\n        1.0\n      );\n      break;\n\n    case \"nose\":\n      newDamage.noseBleeding = Math.min(\n        currentDamage.noseBleeding + damageIntensity * 0.5,\n        1.0\n      );\n      break;\n\n    case \"forehead\":\n    case \"crown\":\n      newDamage.foreheadBruise = Math.min(\n        currentDamage.foreheadBruise + damageIntensity * 0.3,\n        1.0\n      );\n      break;\n\n    case \"cheek_left\":\n      newDamage.leftCheekBruise = Math.min(\n        currentDamage.leftCheekBruise + damageIntensity * 0.4,\n        1.0\n      );\n      break;\n\n    case \"cheek_right\":\n      newDamage.rightCheekBruise = Math.min(\n        currentDamage.rightCheekBruise + damageIntensity * 0.4,\n        1.0\n      );\n      break;\n\n    default:\n      // General facial hit - add minor bruising\n      newDamage.leftCheekBruise = Math.min(\n        currentDamage.leftCheekBruise + damageIntensity * 0.1,\n        1.0\n      );\n      newDamage.rightCheekBruise = Math.min(\n        currentDamage.rightCheekBruise + damageIntensity * 0.1,\n        1.0\n      );\n      break;\n  }\n\n  // Update total facial damage\n  newDamage.totalFacialDamage = Math.min(\n    currentDamage.totalFacialDamage + damageAmount,\n    100\n  );\n\n  return newDamage;\n};\n\n/**\n * Reset facial damage (for new round or healing)\n * \n * @param partialReset - If true, only reduces damage by percentage (healing)\n * @param resetPercentage - Percentage to reduce damage (0-1)\n * @returns Fresh facial damage state\n * \n * @public\n * @korean 얼굴손상초기화\n */\nexport const resetFacialDamage = (\n  currentDamage: FacialDamageState,\n  partialReset = false,\n  resetPercentage = 1.0\n): FacialDamageState => {\n  if (!partialReset) {\n    return DEFAULT_FACIAL_DAMAGE;\n  }\n\n  // Partial healing - reduce all damage values\n  const healingFactor = 1.0 - resetPercentage;\n  return {\n    leftEyeSwelling: currentDamage.leftEyeSwelling * healingFactor,\n    rightEyeSwelling: currentDamage.rightEyeSwelling * healingFactor,\n    mouthBleeding: currentDamage.mouthBleeding * healingFactor,\n    noseBleeding: currentDamage.noseBleeding * healingFactor,\n    leftCheekBruise: currentDamage.leftCheekBruise * healingFactor,\n    rightCheekBruise: currentDamage.rightCheekBruise * healingFactor,\n    foreheadBruise: currentDamage.foreheadBruise * healingFactor,\n    jawBruise: currentDamage.jawBruise * healingFactor,\n    totalFacialDamage: currentDamage.totalFacialDamage * healingFactor,\n  };\n};\n\n/**\n * Get expression intensity based on combat state\n * \n * Expression intensity affects degree of facial movement.\n * Higher pain/damage = more intense expressions.\n * \n * @param expression - Current facial expression\n * @param pain - Pain level (0-100)\n * @param stamina - Stamina level (0-100)\n * @returns Expression intensity (0-1)\n * \n * @public\n * @korean 표정강도가져오기\n */\nexport const getExpressionIntensity = (\n  expression: FacialExpression,\n  pain: number,\n  stamina: number\n): number => {\n  switch (expression) {\n    case FacialExpression.PAINED:\n      // Higher pain = more intense pained expression\n      return Math.min(pain / 100, 1.0);\n\n    case FacialExpression.EXHAUSTED:\n      // Lower stamina = more intense exhaustion\n      return Math.min(1.0 - stamina / 100, 1.0);\n\n    case FacialExpression.FOCUSED:\n      // High stamina = more intense focus\n      return Math.min(stamina / 100, 1.0);\n\n    case FacialExpression.VICTORIOUS:\n      // Brief, moderate intensity\n      return 0.7;\n\n    case FacialExpression.DEFEATED:\n      // Full intensity (unconscious)\n      return 1.0;\n\n    case FacialExpression.NEUTRAL:\n    default:\n      // Default intensity\n      return 1.0;\n  }\n};\n\n/**\n * Create default expression state\n * \n * @returns Default neutral expression state\n * \n * @public\n * @korean 기본표정상태생성\n */\nexport const createDefaultExpressionState = (): ExpressionState => {\n  return { ...DEFAULT_EXPRESSION_STATE };\n};\n\n/**\n * Create default facial damage state\n * \n * @returns Default facial damage state with no damage\n * \n * @public\n * @korean 기본얼굴손상생성\n */\nexport const createDefaultFacialDamage = (): FacialDamageState => {\n  return { ...DEFAULT_FACIAL_DAMAGE };\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwFA,IAAa,gCACX,QACA,WACA,SACA,OACA,eACA,SACA,eACqB;AAErB,KAAI,gBAAgB,GAClB,QAAO,iBAAiB;AAI1B,KAAI,QACF,QAAO,iBAAiB;AAI1B,KAAI,UAAU,GACZ,QAAO,iBAAiB;AAI1B,KAAI,WACF,QAAO,iBAAiB;CAI1B,MAAM,mBAAoB,SAAS,YAAa;AAChD,KAAI,UAAU,MAAM,mBAAmB,GACrC,QAAO,iBAAiB;AAI1B,QAAO,iBAAiB;;;;;;;;;;AAwS1B,IAAa,kCAAqD;AAChE,QAAO,EAAE,GAAG,uBAAuB"}