blacktrigram 0.7.2

package/lib/utils/sharedPhysicsConfig.d.ts

@@ -0,0 +1,125 @@
+/**
+ * Shared physics configuration for Black Trigram screens.
+ *
+ * **Korean**: 공유 물리 설정
+ *
+ * This module provides shared physics configuration utilities to ensure
+ * consistent physics behavior, coordinate systems, and camera setup across
+ * TrainingScreen3D and CombatScreen3D.
+ *
+ * ## Synchronization Guarantees
+ *
+ * All screens using these utilities will have:
+ * - Identical camera FOV and positioning for same device types
+ * - Consistent arena bounds calculations
+ * - Same physics constants (acceleration, stamina regen, etc.)
+ * - Unified coordinate system (meter-based)
+ * - Matching movement speed and range calculations
+ *
+ * @module utils/sharedPhysicsConfig
+ * @category Physics
+ * @korean 공유물리설정
+ */
+import { COMBAT_RANGES_METERS } from "../types/physicsConstants";
+import { type ArenaConfiguration } from "./arenaWorldDimensions";
+/**
+ * Camera configuration for 3D rendering.
+ *
+ * **Korean**: 카메라 설정
+ *
+ * @public
+ */
+export interface CameraConfiguration {
+    /** Field of view in degrees */
+    readonly fov: number;
+    /** Camera position [x, y, z] in meters */
+    readonly position: readonly [number, number, number];
+    /** Near clipping plane */
+    readonly near: number;
+    /** Far clipping plane */
+    readonly far: number;
+}
+/**
+ * Complete physics configuration for a game screen.
+ *
+ * **Korean**: 물리 설정
+ *
+ * Includes all parameters needed to ensure consistent physics
+ * behavior across different screens and device types.
+ *
+ * @public
+ */
+export interface PhysicsConfiguration {
+    /** Arena configuration with pixel and meter dimensions */
+    readonly arenaConfig: ArenaConfiguration;
+    /** Camera configuration for consistent perspective */
+    readonly cameraConfig: CameraConfiguration;
+    /** Base stamina regeneration rate (stamina/second) */
+    readonly staminaRegenRate: number;
+    /** Base movement acceleration (m/s²) */
+    readonly movementAcceleration: number;
+    /** Combat ranges in meters */
+    readonly combatRanges: typeof COMBAT_RANGES_METERS;
+    /** Pixels per meter ratio for this configuration */
+    readonly pixelsPerMeter: number;
+}
+/**
+ * Create camera configuration based on device type.
+ *
+ * Mobile devices get a tighter FOV and closer camera position
+ * for better framing of the smaller arena. Desktop gets a wider
+ * FOV and further camera for full arena view.
+ *
+ * **Korean**: 카메라 설정 생성
+ *
+ * @param isMobile - Whether the device is mobile
+ * @returns Camera configuration for device type
+ *
+ * @example
+ * ```typescript
+ * const mobile = createCameraConfig(true);
+ * // { fov: 55, position: [0, 6, 10], near: 0.1, far: 1000 }
+ *
+ * const desktop = createCameraConfig(false);
+ * // { fov: 60, position: [0, 8, 12], near: 0.1, far: 1000 }
+ * ```
+ *
+ * @public
+ */
+export declare function createCameraConfig(isMobile: boolean): CameraConfiguration;
+/**
+ * Create complete physics configuration for a screen.
+ *
+ * This is the primary function for setting up physics in both
+ * TrainingScreen3D and CombatScreen3D. It ensures consistent
+ * physics behavior by using the same calculations and constants.
+ *
+ * **Korean**: 물리 설정 생성
+ *
+ * @param screenWidth - Screen width in pixels
+ * @param screenHeight - Screen height in pixels
+ * @param topOffset - Pixels reserved at top (HUD, headers)
+ * @param bottomOffset - Pixels reserved at bottom (controls, footer)
+ * @param isMobile - Whether the device is mobile
+ * @returns Complete physics configuration
+ *
+ * @example
+ * ```typescript
+ * // Training screen
+ * const trainingPhysics = createPhysicsConfig(
+ *   1920, 1080, 60, 100, false
+ * );
+ *
+ * // Combat screen
+ * const combatPhysics = createPhysicsConfig(
+ *   1920, 1080, 60, 100, false
+ * );
+ *
+ * // Both have identical physics configuration
+ * trainingPhysics.pixelsPerMeter === combatPhysics.pixelsPerMeter; // true
+ * ```
+ *
+ * @public
+ */
+export declare function createPhysicsConfig(screenWidth: number, screenHeight: number, topOffset: number, bottomOffset: number, isMobile: boolean): PhysicsConfiguration;
+//# sourceMappingURL=sharedPhysicsConfig.d.ts.map

package/lib/utils/sharedPhysicsConfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sharedPhysicsConfig.d.ts","sourceRoot":"","sources":["../../src/utils/sharedPhysicsConfig.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,EAGL,oBAAoB,EACrB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAEL,KAAK,kBAAkB,EACxB,MAAM,wBAAwB,CAAC;AAEhC;;;;;;GAMG;AACH,MAAM,WAAW,mBAAmB;IAClC,+BAA+B;IAC/B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,0CAA0C;IAC1C,QAAQ,CAAC,QAAQ,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IACrD,0BAA0B;IAC1B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,yBAAyB;IACzB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;CACtB;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,oBAAoB;IACnC,0DAA0D;IAC1D,QAAQ,CAAC,WAAW,EAAE,kBAAkB,CAAC;IACzC,sDAAsD;IACtD,QAAQ,CAAC,YAAY,EAAE,mBAAmB,CAAC;IAC3C,sDAAsD;IACtD,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC,wCAAwC;IACxC,QAAQ,CAAC,oBAAoB,EAAE,MAAM,CAAC;IACtC,8BAA8B;IAC9B,QAAQ,CAAC,YAAY,EAAE,OAAO,oBAAoB,CAAC;IACnD,oDAAoD;IACpD,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;CACjC;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,OAAO,GAAG,mBAAmB,CAgBzE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAgB,mBAAmB,CACjC,WAAW,EAAE,MAAM,EACnB,YAAY,EAAE,MAAM,EACpB,SAAS,EAAE,MAAM,EACjB,YAAY,EAAE,MAAM,EACpB,QAAQ,EAAE,OAAO,GAChB,oBAAoB,CAoBtB"}

package/lib/utils/sharedPhysicsConfig.js

@@ -0,0 +1,119 @@
+import { COMBAT_RANGES_METERS } from "../types/physicsConstants.js";
+import { calculateArenaConfiguration } from "./arenaWorldDimensions.js";
+//#region src/utils/sharedPhysicsConfig.ts
+/**
+* Shared physics configuration for Black Trigram screens.
+*
+* **Korean**: 공유 물리 설정
+*
+* This module provides shared physics configuration utilities to ensure
+* consistent physics behavior, coordinate systems, and camera setup across
+* TrainingScreen3D and CombatScreen3D.
+*
+* ## Synchronization Guarantees
+*
+* All screens using these utilities will have:
+* - Identical camera FOV and positioning for same device types
+* - Consistent arena bounds calculations
+* - Same physics constants (acceleration, stamina regen, etc.)
+* - Unified coordinate system (meter-based)
+* - Matching movement speed and range calculations
+*
+* @module utils/sharedPhysicsConfig
+* @category Physics
+* @korean 공유물리설정
+*/
+/**
+* Create camera configuration based on device type.
+*
+* Mobile devices get a tighter FOV and closer camera position
+* for better framing of the smaller arena. Desktop gets a wider
+* FOV and further camera for full arena view.
+*
+* **Korean**: 카메라 설정 생성
+*
+* @param isMobile - Whether the device is mobile
+* @returns Camera configuration for device type
+*
+* @example
+* ```typescript
+* const mobile = createCameraConfig(true);
+* // { fov: 55, position: [0, 6, 10], near: 0.1, far: 1000 }
+*
+* const desktop = createCameraConfig(false);
+* // { fov: 60, position: [0, 8, 12], near: 0.1, far: 1000 }
+* ```
+*
+* @public
+*/
+function createCameraConfig(isMobile) {
+	if (isMobile) return {
+		fov: 55,
+		position: [
+			0,
+			6,
+			10
+		],
+		near: .1,
+		far: 1e3
+	};
+	return {
+		fov: 60,
+		position: [
+			0,
+			8,
+			12
+		],
+		near: .1,
+		far: 1e3
+	};
+}
+/**
+* Create complete physics configuration for a screen.
+*
+* This is the primary function for setting up physics in both
+* TrainingScreen3D and CombatScreen3D. It ensures consistent
+* physics behavior by using the same calculations and constants.
+*
+* **Korean**: 물리 설정 생성
+*
+* @param screenWidth - Screen width in pixels
+* @param screenHeight - Screen height in pixels
+* @param topOffset - Pixels reserved at top (HUD, headers)
+* @param bottomOffset - Pixels reserved at bottom (controls, footer)
+* @param isMobile - Whether the device is mobile
+* @returns Complete physics configuration
+*
+* @example
+* ```typescript
+* // Training screen
+* const trainingPhysics = createPhysicsConfig(
+*   1920, 1080, 60, 100, false
+* );
+*
+* // Combat screen
+* const combatPhysics = createPhysicsConfig(
+*   1920, 1080, 60, 100, false
+* );
+*
+* // Both have identical physics configuration
+* trainingPhysics.pixelsPerMeter === combatPhysics.pixelsPerMeter; // true
+* ```
+*
+* @public
+*/
+function createPhysicsConfig(screenWidth, screenHeight, topOffset, bottomOffset, isMobile) {
+	const arenaConfig = calculateArenaConfiguration(screenWidth, screenHeight, topOffset, bottomOffset);
+	return {
+		arenaConfig,
+		cameraConfig: createCameraConfig(isMobile),
+		staminaRegenRate: 15,
+		movementAcceleration: 30,
+		combatRanges: COMBAT_RANGES_METERS,
+		pixelsPerMeter: arenaConfig.pixelsPerMeter
+	};
+}
+//#endregion
+export { createCameraConfig, createPhysicsConfig };
+
+//# sourceMappingURL=sharedPhysicsConfig.js.map

package/lib/utils/sharedPhysicsConfig.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sharedPhysicsConfig.js","names":[],"sources":["../../src/utils/sharedPhysicsConfig.ts"],"sourcesContent":["/**\n * Shared physics configuration for Black Trigram screens.\n *\n * **Korean**: 공유 물리 설정\n *\n * This module provides shared physics configuration utilities to ensure\n * consistent physics behavior, coordinate systems, and camera setup across\n * TrainingScreen3D and CombatScreen3D.\n *\n * ## Synchronization Guarantees\n *\n * All screens using these utilities will have:\n * - Identical camera FOV and positioning for same device types\n * - Consistent arena bounds calculations\n * - Same physics constants (acceleration, stamina regen, etc.)\n * - Unified coordinate system (meter-based)\n * - Matching movement speed and range calculations\n *\n * @module utils/sharedPhysicsConfig\n * @category Physics\n * @korean 공유물리설정\n */\n\nimport {\n  BASE_STAMINA_REGEN_RATE,\n  BASE_MOVEMENT_ACCELERATION,\n  COMBAT_RANGES_METERS,\n} from \"@/types/physicsConstants\";\nimport {\n  calculateArenaConfiguration,\n  type ArenaConfiguration,\n} from \"./arenaWorldDimensions\";\n\n/**\n * Camera configuration for 3D rendering.\n *\n * **Korean**: 카메라 설정\n *\n * @public\n */\nexport interface CameraConfiguration {\n  /** Field of view in degrees */\n  readonly fov: number;\n  /** Camera position [x, y, z] in meters */\n  readonly position: readonly [number, number, number];\n  /** Near clipping plane */\n  readonly near: number;\n  /** Far clipping plane */\n  readonly far: number;\n}\n\n/**\n * Complete physics configuration for a game screen.\n *\n * **Korean**: 물리 설정\n *\n * Includes all parameters needed to ensure consistent physics\n * behavior across different screens and device types.\n *\n * @public\n */\nexport interface PhysicsConfiguration {\n  /** Arena configuration with pixel and meter dimensions */\n  readonly arenaConfig: ArenaConfiguration;\n  /** Camera configuration for consistent perspective */\n  readonly cameraConfig: CameraConfiguration;\n  /** Base stamina regeneration rate (stamina/second) */\n  readonly staminaRegenRate: number;\n  /** Base movement acceleration (m/s²) */\n  readonly movementAcceleration: number;\n  /** Combat ranges in meters */\n  readonly combatRanges: typeof COMBAT_RANGES_METERS;\n  /** Pixels per meter ratio for this configuration */\n  readonly pixelsPerMeter: number;\n}\n\n/**\n * Create camera configuration based on device type.\n *\n * Mobile devices get a tighter FOV and closer camera position\n * for better framing of the smaller arena. Desktop gets a wider\n * FOV and further camera for full arena view.\n *\n * **Korean**: 카메라 설정 생성\n *\n * @param isMobile - Whether the device is mobile\n * @returns Camera configuration for device type\n *\n * @example\n * ```typescript\n * const mobile = createCameraConfig(true);\n * // { fov: 55, position: [0, 6, 10], near: 0.1, far: 1000 }\n *\n * const desktop = createCameraConfig(false);\n * // { fov: 60, position: [0, 8, 12], near: 0.1, far: 1000 }\n * ```\n *\n * @public\n */\nexport function createCameraConfig(isMobile: boolean): CameraConfiguration {\n  if (isMobile) {\n    return {\n      fov: 55, // Tighter FOV for smaller mobile arena\n      position: [0, 6, 10], // Closer camera\n      near: 0.1,\n      far: 1000,\n    };\n  }\n\n  return {\n    fov: 60, // Standard FOV for desktop\n    position: [0, 8, 12], // Further back for full view\n    near: 0.1,\n    far: 1000,\n  };\n}\n\n/**\n * Create complete physics configuration for a screen.\n *\n * This is the primary function for setting up physics in both\n * TrainingScreen3D and CombatScreen3D. It ensures consistent\n * physics behavior by using the same calculations and constants.\n *\n * **Korean**: 물리 설정 생성\n *\n * @param screenWidth - Screen width in pixels\n * @param screenHeight - Screen height in pixels\n * @param topOffset - Pixels reserved at top (HUD, headers)\n * @param bottomOffset - Pixels reserved at bottom (controls, footer)\n * @param isMobile - Whether the device is mobile\n * @returns Complete physics configuration\n *\n * @example\n * ```typescript\n * // Training screen\n * const trainingPhysics = createPhysicsConfig(\n *   1920, 1080, 60, 100, false\n * );\n *\n * // Combat screen\n * const combatPhysics = createPhysicsConfig(\n *   1920, 1080, 60, 100, false\n * );\n *\n * // Both have identical physics configuration\n * trainingPhysics.pixelsPerMeter === combatPhysics.pixelsPerMeter; // true\n * ```\n *\n * @public\n */\nexport function createPhysicsConfig(\n  screenWidth: number,\n  screenHeight: number,\n  topOffset: number,\n  bottomOffset: number,\n  isMobile: boolean,\n): PhysicsConfiguration {\n  // Calculate arena dimensions (same for both screens)\n  const arenaConfig = calculateArenaConfiguration(\n    screenWidth,\n    screenHeight,\n    topOffset,\n    bottomOffset,\n  );\n\n  // Create camera config based on device type\n  const cameraConfig = createCameraConfig(isMobile);\n\n  return {\n    arenaConfig,\n    cameraConfig,\n    staminaRegenRate: BASE_STAMINA_REGEN_RATE,\n    movementAcceleration: BASE_MOVEMENT_ACCELERATION,\n    combatRanges: COMBAT_RANGES_METERS,\n    pixelsPerMeter: arenaConfig.pixelsPerMeter,\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmGA,SAAgB,mBAAmB,UAAwC;AACzE,KAAI,SACF,QAAO;EACL,KAAK;EACL,UAAU;GAAC;GAAG;GAAG;GAAG;EACpB,MAAM;EACN,KAAK;EACN;AAGH,QAAO;EACL,KAAK;EACL,UAAU;GAAC;GAAG;GAAG;GAAG;EACpB,MAAM;EACN,KAAK;EACN;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqCH,SAAgB,oBACd,aACA,cACA,WACA,cACA,UACsB;CAEtB,MAAM,cAAc,4BAClB,aACA,cACA,WACA,aACD;AAKD,QAAO;EACL;EACA,cAJmB,mBAAmB,SAAS;EAK/C,kBAAA;EACA,sBAAA;EACA,cAAc;EACd,gBAAgB,YAAY;EAC7B"}

package/lib/utils/skeletonScaling.d.ts

@@ -0,0 +1,285 @@
+/**
+ * Skeleton rig scaling based on physical attributes.
+ *
+ * **Korean**: 골격 크기 조정 (Skeleton Scaling)
+ *
+ * This module provides functions to scale the skeleton rig based on player
+ * physical attributes, allowing each archetype to have anatomically accurate
+ * body proportions that affect combat hitboxes, vital point positioning, and
+ * visual representation.
+ *
+ * ## Visual Amplification System
+ *
+ * Raw physical attribute differences between archetypes are subtle (2-12%).
+ * To create recognizable visual silhouettes in 3D, this system applies
+ * amplification factors that enhance differences while maintaining realistic
+ * proportions:
+ *
+ * - **Limb Scaling**: 2.5x amplification (subtle 5% difference → 12.5% visual)
+ * - **Shoulder Width**: 1.15x additional amplification for silhouette distinction
+ * - **Overall Height**: 1.5x amplification (kept subtle for realism)
+ *
+ * ### Expected Visual Silhouettes
+ *
+ * Each archetype has a distinct, recognizable body shape:
+ *
+ * - **해커 (Hacker)**: Compact, narrow shoulders (43cm), shortest limbs - SMALLEST
+ * - **암살자 (Amsalja)**: Tall (186cm), lean, long limbs (102cm legs) - TALLEST
+ * - **정보요원 (Jeongbo)**: Balanced, average proportions - BASELINE
+ * - **무사 (Musa)**: Athletic military build (46cm shoulders) - TRADITIONAL
+ * - **조직폭력배 (Jojik)**: Massive, widest shoulders (54cm), imposing - LARGEST
+ *
+ * ## Integration with Korean Anatomy
+ *
+ * The scaling system respects Korean martial arts anatomy principles:
+ * - **Head vital points** (두부 급소) scale with head size
+ * - **Neck vulnerability** (경부 취약성) affected by neck length
+ * - **Torso vital points** (몸통 급소) distributed across torso length
+ * - **Limb reach** (팔다리 거리) determined by arm/leg length
+ * - **Shoulder defense** (어깨 방어) coverage from shoulder width
+ *
+ * @module utils/skeletonScaling
+ * @category Combat System
+ * @korean 골격조정
+ */
+import { PhysicalAttributes } from "../types";
+/**
+ * Bone scaling factors for each body region.
+ *
+ * **Korean**: 뼈 크기 비율 (Bone Scaling Factors)
+ *
+ * Defines how physical attributes map to skeleton bone scaling.
+ * Each factor is a multiplier applied to the base bone length.
+ *
+ * @public
+ * @korean 뼈크기비율
+ */
+export interface BoneScalingFactors {
+    /** Head bone scaling (based on headSize) */
+    readonly head: number;
+    /** Neck bone scaling (based on neckLength) */
+    readonly neck: number;
+    /** Spine bones scaling (based on torsoLength) */
+    readonly spine: number;
+    /** Upper arm bones scaling (based on armLength) */
+    readonly upperArm: number;
+    /** Forearm bones scaling (based on armLength) */
+    readonly forearm: number;
+    /** Thigh bones scaling (based on legLength) */
+    readonly thigh: number;
+    /** Shin bones scaling (based on legLength) */
+    readonly shin: number;
+    /** Shoulder bones scaling (based on shoulderWidth) */
+    readonly shoulder: number;
+    /** Overall skeleton scaling (based on totalHeight) */
+    readonly overall: number;
+}
+/**
+ * Calculate bone scaling factors from physical attributes.
+ *
+ * **Korean**: 뼈 크기 비율 계산 (Calculate Bone Scaling Factors)
+ *
+ * Computes scaling multipliers for each bone region based on the
+ * player's physical attributes compared to reference values.
+ * Differences are amplified for more noticeable visual distinction
+ * between archetypes.
+ *
+ * @param attributes - Player's physical attributes
+ * @returns Bone scaling factors for skeleton rig
+ *
+ * @example
+ * ```typescript
+ * const factors = calculateBoneScalingFactors(AMSALJA_PHYSICAL);
+ * // Amsalja has longer legs: factors.thigh ~= 1.06 (amplified from ~1.03)
+ * // Amsalja has smaller head: factors.head ~= 0.90 (amplified from ~0.95)
+ * ```
+ *
+ * @public
+ * @korean 뼈크기비율계산
+ */
+export declare function calculateBoneScalingFactors(attributes: PhysicalAttributes): BoneScalingFactors;
+/**
+ * Get scaled bone length for a specific bone.
+ *
+ * **Korean**: 크기 조정된 뼈 길이 (Scaled Bone Length)
+ *
+ * Returns the scaled length for a specific bone based on the player's
+ * physical attributes. Used when creating or updating skeleton rigs.
+ *
+ * @param boneName - Name of the bone to scale
+ * @param attributes - Player's physical attributes
+ * @returns Scaled bone length in centimeters
+ *
+ * @example
+ * ```typescript
+ * const headLength = getScaledBoneLength(BoneName.HEAD, JOJIK_PHYSICAL);
+ * // Jojik has larger head: returns ~23cm (base 20cm * 1.15)
+ * ```
+ *
+ * @public
+ * @korean 크기조정된뼈길이
+ */
+export declare function getScaledBoneLength(boneName: string, attributes: PhysicalAttributes): number;
+/**
+ * Calculate scaled shoulder offset for skeleton positioning.
+ *
+ * **Korean**: 어깨 오프셋 계산 (Shoulder Offset Calculation)
+ *
+ * Determines the horizontal offset for shoulder bones based on
+ * shoulder width. Used to position arms correctly on the skeleton.
+ *
+ * Applies amplification to shoulder width for more noticeable silhouette
+ * differences between archetypes:
+ * - Jojik (54cm): Offset = 31.05cm (54/2 * 1.15) - WIDE, imposing
+ * - Hacker (43cm): Offset = 24.73cm (43/2 * 1.15) - NARROW, compact
+ * - Difference: 26% wider shoulder span for visual distinction
+ *
+ * @param attributes - Player's physical attributes
+ * @returns Shoulder offset in centimeters (half of total shoulder width, amplified)
+ *
+ * @example
+ * ```typescript
+ * const offset = calculateShoulderOffset(JOJIK_PHYSICAL);
+ * // Jojik has wide shoulders: returns ~31cm (54cm width / 2 * 1.15)
+ * // Left shoulder at -31cm, right shoulder at +31cm
+ * ```
+ *
+ * @public
+ * @korean 어깨오프셋계산
+ */
+export declare function calculateShoulderOffset(attributes: PhysicalAttributes): number;
+/**
+ * Calculate hitbox dimensions based on physical attributes.
+ *
+ * **Korean**: 히트박스 크기 계산 (Hitbox Dimension Calculation)
+ *
+ * Determines the bounding box dimensions for collision detection
+ * and hit registration based on body proportions.
+ *
+ * @param attributes - Player's physical attributes
+ * @returns Hitbox dimensions {width, height, depth} in centimeters
+ *
+ * @example
+ * ```typescript
+ * const hitbox = calculateHitboxDimensions(AMSALJA_PHYSICAL);
+ * // Amsalja is tall and lean: {width: 40, height: 182, depth: 25}
+ * ```
+ *
+ * @public
+ * @korean 히트박스크기계산
+ */
+export declare function calculateHitboxDimensions(attributes: PhysicalAttributes): {
+    width: number;
+    height: number;
+    depth: number;
+};
+/**
+ * Calculate vital point offset adjustments based on body proportions.
+ *
+ * **Korean**: 급소 위치 조정 (Vital Point Position Adjustment)
+ *
+ * Adjusts vital point positions based on scaled skeleton dimensions.
+ * Ensures vital points remain anatomically accurate for different
+ * body types while maintaining Korean anatomy principles.
+ *
+ * @param vitalPointId - ID of the vital point to adjust
+ * @param attributes - Player's physical attributes
+ * @returns Position adjustment {x, y} offset in centimeters
+ *
+ * @example
+ * ```typescript
+ * const adjustment = calculateVitalPointAdjustment("head_temple", MUSA_PHYSICAL);
+ * // Returns offset based on head size and torso height
+ * ```
+ *
+ * @public
+ * @korean 급소위치조정
+ */
+export declare function calculateVitalPointAdjustment(vitalPointId: string, attributes: PhysicalAttributes): {
+    x: number;
+    y: number;
+};
+/**
+ * Calculate choke effectiveness modifier based on neck dimensions.
+ *
+ * **Korean**: 목 조르기 효과 계산 (Choke Effectiveness Calculation)
+ *
+ * Determines how effective chokes and strangles are based on neck
+ * length and thickness. Longer, thinner necks are more vulnerable.
+ *
+ * @param attributes - Player's physical attributes
+ * @returns Choke effectiveness multiplier (1.0 = baseline)
+ *
+ * @example
+ * ```typescript
+ * const chokeEffectiveness = calculateChokeEffectiveness(AMSALJA_PHYSICAL);
+ * // Amsalja has longer neck: returns ~1.1 (10% more vulnerable)
+ *
+ * const jojikChoke = calculateChokeEffectiveness(JOJIK_PHYSICAL);
+ * // Jojik has shorter, thicker neck: returns ~0.9 (10% more resistant)
+ * ```
+ *
+ * @public
+ * @korean 목조르기효과계산
+ */
+export declare function calculateChokeEffectiveness(attributes: PhysicalAttributes): number;
+/**
+ * Calculate head strike vulnerability based on head size.
+ *
+ * **Korean**: 머리 타격 취약성 계산 (Head Strike Vulnerability)
+ *
+ * Determines vulnerability to head strikes based on head size.
+ * Larger heads have more mass and resistance, smaller heads are
+ * more vulnerable to concussive force.
+ *
+ * @param attributes - Player's physical attributes
+ * @returns Head strike vulnerability multiplier (1.0 = baseline)
+ *
+ * @example
+ * ```typescript
+ * const headVuln = calculateHeadStrikeVulnerability(JOJIK_PHYSICAL);
+ * // Jojik has larger head: returns ~0.95 (5% more resistant)
+ * ```
+ *
+ * @public
+ * @korean 머리타격취약성계산
+ */
+export declare function calculateHeadStrikeVulnerability(attributes: PhysicalAttributes): number;
+/**
+ * Calculate body radius for hit distance calculation.
+ *
+ * **Korean**: 몸체 반경 계산 (Body Radius Calculation)
+ *
+ * When calculating hit distance, we measure center-to-center, but attacks
+ * land on the target's body surface. This function calculates the effective
+ * "depth" of a fighter's body from their center point based on their
+ * physical attributes.
+ *
+ * The calculation uses torso depth derived from shoulder width, as broader
+ * fighters have proportionally deeper torsos. This is more anatomically
+ * accurate than using a fixed constant.
+ *
+ * Formula: shoulderWidth * 0.5 (torso depth ratio) / 100 (cm to meters)
+ *
+ * Example body radii:
+ * - Hacker (43cm shoulders): 0.215m depth → 0.215m radius
+ * - Musa (46cm shoulders): 0.23m depth → 0.23m radius
+ * - Jojik (54cm shoulders): 0.27m depth → 0.27m radius
+ *
+ * @param attributes - Player's physical attributes
+ * @returns Body radius in meters (distance from center to body surface)
+ *
+ * @example
+ * ```typescript
+ * const radius = calculateBodyRadius(JOJIK_PHYSICAL);
+ * // Jojik has wide shoulders (54cm): returns 0.27m
+ *
+ * const hackerRadius = calculateBodyRadius(HACKER_PHYSICAL);
+ * // Hacker is lean (43cm shoulders): returns 0.215m
+ * ```
+ *
+ * @public
+ * @korean 몸체반경계산
+ */
+export declare function calculateBodyRadius(attributes: PhysicalAttributes): number;
+//# sourceMappingURL=skeletonScaling.d.ts.map

package/lib/utils/skeletonScaling.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skeletonScaling.d.ts","sourceRoot":"","sources":["../../src/utils/skeletonScaling.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AAEH,OAAO,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAO7C;;;;;;;;;;GAUG;AACH,MAAM,WAAW,kBAAkB;IACjC,4CAA4C;IAC5C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,8CAA8C;IAC9C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,iDAAiD;IACjD,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,mDAAmD;IACnD,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,iDAAiD;IACjD,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,+CAA+C;IAC/C,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,8CAA8C;IAC9C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,sDAAsD;IACtD,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,sDAAsD;IACtD,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAqED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,2BAA2B,CACzC,UAAU,EAAE,kBAAkB,GAC7B,kBAAkB,CAwCpB;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,kBAAkB,GAC7B,MAAM,CAkDR;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,uBAAuB,CACrC,UAAU,EAAE,kBAAkB,GAC7B,MAAM,CAKR;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,yBAAyB,CAAC,UAAU,EAAE,kBAAkB,GAAG;IACzE,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;CACf,CAMA;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,6BAA6B,CAC3C,YAAY,EAAE,MAAM,EACpB,UAAU,EAAE,kBAAkB,GAC7B;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,CA6C1B;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,2BAA2B,CACzC,UAAU,EAAE,kBAAkB,GAC7B,MAAM,CASR;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,gCAAgC,CAC9C,UAAU,EAAE,kBAAkB,GAC7B,MAAM,CAOR;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wBAAgB,mBAAmB,CAAC,UAAU,EAAE,kBAAkB,GAAG,MAAM,CAU1E"}

package/lib/utils/skeletonScaling.js

@@ -0,0 +1,46 @@
+import "../types/skeletal.js";
+import { REFERENCE_ATTRIBUTES as REFERENCE_ATTRIBUTES$1 } from "../constants/bodyRenderingConstants.js";
+({ ...REFERENCE_ATTRIBUTES$1 });
+/**
+* Calculate body radius for hit distance calculation.
+*
+* **Korean**: 몸체 반경 계산 (Body Radius Calculation)
+*
+* When calculating hit distance, we measure center-to-center, but attacks
+* land on the target's body surface. This function calculates the effective
+* "depth" of a fighter's body from their center point based on their
+* physical attributes.
+*
+* The calculation uses torso depth derived from shoulder width, as broader
+* fighters have proportionally deeper torsos. This is more anatomically
+* accurate than using a fixed constant.
+*
+* Formula: shoulderWidth * 0.5 (torso depth ratio) / 100 (cm to meters)
+*
+* Example body radii:
+* - Hacker (43cm shoulders): 0.215m depth → 0.215m radius
+* - Musa (46cm shoulders): 0.23m depth → 0.23m radius
+* - Jojik (54cm shoulders): 0.27m depth → 0.27m radius
+*
+* @param attributes - Player's physical attributes
+* @returns Body radius in meters (distance from center to body surface)
+*
+* @example
+* ```typescript
+* const radius = calculateBodyRadius(JOJIK_PHYSICAL);
+* // Jojik has wide shoulders (54cm): returns 0.27m
+*
+* const hackerRadius = calculateBodyRadius(HACKER_PHYSICAL);
+* // Hacker is lean (43cm shoulders): returns 0.215m
+* ```
+*
+* @public
+* @korean 몸체반경계산
+*/
+function calculateBodyRadius(attributes) {
+	return attributes.shoulderWidth * .5 / 100;
+}
+//#endregion
+export { calculateBodyRadius };
+
+//# sourceMappingURL=skeletonScaling.js.map

package/lib/utils/skeletonScaling.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"skeletonScaling.js","names":[],"sources":["../../src/utils/skeletonScaling.ts"],"sourcesContent":["/**\n * Skeleton rig scaling based on physical attributes.\n *\n * **Korean**: 골격 크기 조정 (Skeleton Scaling)\n *\n * This module provides functions to scale the skeleton rig based on player\n * physical attributes, allowing each archetype to have anatomically accurate\n * body proportions that affect combat hitboxes, vital point positioning, and\n * visual representation.\n *\n * ## Visual Amplification System\n *\n * Raw physical attribute differences between archetypes are subtle (2-12%).\n * To create recognizable visual silhouettes in 3D, this system applies\n * amplification factors that enhance differences while maintaining realistic\n * proportions:\n *\n * - **Limb Scaling**: 2.5x amplification (subtle 5% difference → 12.5% visual)\n * - **Shoulder Width**: 1.15x additional amplification for silhouette distinction\n * - **Overall Height**: 1.5x amplification (kept subtle for realism)\n *\n * ### Expected Visual Silhouettes\n *\n * Each archetype has a distinct, recognizable body shape:\n *\n * - **해커 (Hacker)**: Compact, narrow shoulders (43cm), shortest limbs - SMALLEST\n * - **암살자 (Amsalja)**: Tall (186cm), lean, long limbs (102cm legs) - TALLEST\n * - **정보요원 (Jeongbo)**: Balanced, average proportions - BASELINE\n * - **무사 (Musa)**: Athletic military build (46cm shoulders) - TRADITIONAL\n * - **조직폭력배 (Jojik)**: Massive, widest shoulders (54cm), imposing - LARGEST\n *\n * ## Integration with Korean Anatomy\n *\n * The scaling system respects Korean martial arts anatomy principles:\n * - **Head vital points** (두부 급소) scale with head size\n * - **Neck vulnerability** (경부 취약성) affected by neck length\n * - **Torso vital points** (몸통 급소) distributed across torso length\n * - **Limb reach** (팔다리 거리) determined by arm/leg length\n * - **Shoulder defense** (어깨 방어) coverage from shoulder width\n *\n * @module utils/skeletonScaling\n * @category Combat System\n * @korean 골격조정\n */\n\nimport { PhysicalAttributes } from \"@/types\";\nimport { BoneName } from \"@/types/skeletal\";\nimport {\n  amplifyScaling,\n  REFERENCE_ATTRIBUTES as BODY_REFERENCE_ATTRIBUTES,\n} from \"../constants/bodyRenderingConstants\";\n\n/**\n * Bone scaling factors for each body region.\n *\n * **Korean**: 뼈 크기 비율 (Bone Scaling Factors)\n *\n * Defines how physical attributes map to skeleton bone scaling.\n * Each factor is a multiplier applied to the base bone length.\n *\n * @public\n * @korean 뼈크기비율\n */\nexport interface BoneScalingFactors {\n  /** Head bone scaling (based on headSize) */\n  readonly head: number;\n  /** Neck bone scaling (based on neckLength) */\n  readonly neck: number;\n  /** Spine bones scaling (based on torsoLength) */\n  readonly spine: number;\n  /** Upper arm bones scaling (based on armLength) */\n  readonly upperArm: number;\n  /** Forearm bones scaling (based on armLength) */\n  readonly forearm: number;\n  /** Thigh bones scaling (based on legLength) */\n  readonly thigh: number;\n  /** Shin bones scaling (based on legLength) */\n  readonly shin: number;\n  /** Shoulder bones scaling (based on shoulderWidth) */\n  readonly shoulder: number;\n  /** Overall skeleton scaling (based on totalHeight) */\n  readonly overall: number;\n}\n\n/**\n * Anatomically correct bone dimensions in centimeters.\n *\n * **Korean**: 해부학적 뼈 치수 (Anatomical Bone Dimensions)\n *\n * These are anatomically accurate bone lengths based on human proportions.\n * For a 178cm reference height, these values create a realistic skeleton.\n *\n * Reference: Human body proportions (8-head canon)\n * - Head: ~12.5% of height (22cm)\n * - Neck: ~5.5% of height (10cm)\n * - Torso: ~33% of height (59cm / 3 segments = 20cm each)\n * - Legs: ~48% of height (85cm total)\n * - Thigh: ~55% of leg length (47cm)\n * - Shin: ~45% of leg length (38cm)\n *\n * @internal\n * @korean 기본뼈치수\n */\nconst BASE_BONE_DIMENSIONS = {\n  // Head region\n  head: 22, // Head bone length in cm (12.5% of 178cm)\n  neck: 10, // Neck bone length in cm (5.5% of 178cm)\n\n  // Torso region - Total torso ~59cm for 178cm person (33%)\n  spineLower: 20, // Lower spine segment (lumbar)\n  spineMiddle: 20, // Middle spine segment (thoracic)\n  spineUpper: 19, // Upper spine segment (upper thoracic)\n  pelvis: 8, // Pelvis/root bone height (~4.5% of height)\n\n  // Arm region (one side) - Total arm ~75cm for 178cm (42% of height)\n  shoulder: 12, // Shoulder/clavicle bone (~6.5% of height)\n  upperArm: 32, // Upper arm (shoulder to elbow) - ~55% of arm\n  forearm: 27, // Forearm (elbow to wrist) - ~45% of arm (including wrist)\n  hand: 19, // Hand length (~10.5% of height)\n\n  // Leg region (one side) - Total leg ~95cm for 178cm (53% of height)\n  hip: 10, // Hip joint height\n  thigh: 48, // Thigh (hip to knee) - ~55% of leg length\n  shin: 40, // Shin (knee to ankle) - ~45% of leg length\n  foot: 5, // Foot/ankle height (ground to ankle)\n\n  // Width measurements\n  shoulderWidth: 43, // Total shoulder width (half = 21.5cm offset)\n  hipWidth: 30, // Total hip width (half = 15cm offset)\n} as const;\n\n/**\n * Reference physical attributes for baseline scaling.\n *\n * **Korean**: 기준 신체 속성 (Reference Physical Attributes)\n *\n * These represent the \"average\" Korean male fighter that the base\n * skeleton rig is designed for. Scaling is calculated relative to\n * these reference values.\n *\n * Uses centralized REFERENCE_ATTRIBUTES from bodyRenderingConstants.\n *\n * @internal\n * @korean 기준신체속성\n */\nconst REFERENCE_ATTRIBUTES: PhysicalAttributes = {\n  ...BODY_REFERENCE_ATTRIBUTES,\n};\n\n// VISUAL_AMPLIFICATION_FACTOR and amplifyScaling imported from bodyRenderingConstants\n\n/**\n * Calculate bone scaling factors from physical attributes.\n *\n * **Korean**: 뼈 크기 비율 계산 (Calculate Bone Scaling Factors)\n *\n * Computes scaling multipliers for each bone region based on the\n * player's physical attributes compared to reference values.\n * Differences are amplified for more noticeable visual distinction\n * between archetypes.\n *\n * @param attributes - Player's physical attributes\n * @returns Bone scaling factors for skeleton rig\n *\n * @example\n * ```typescript\n * const factors = calculateBoneScalingFactors(AMSALJA_PHYSICAL);\n * // Amsalja has longer legs: factors.thigh ~= 1.06 (amplified from ~1.03)\n * // Amsalja has smaller head: factors.head ~= 0.90 (amplified from ~0.95)\n * ```\n *\n * @public\n * @korean 뼈크기비율계산\n */\nexport function calculateBoneScalingFactors(\n  attributes: PhysicalAttributes,\n): BoneScalingFactors {\n  // Calculate raw scaling ratios from physical attributes\n  const rawOverall = attributes.totalHeight / REFERENCE_ATTRIBUTES.totalHeight;\n  const rawHead = attributes.headSize / REFERENCE_ATTRIBUTES.headSize;\n  const rawNeck = attributes.neckLength / REFERENCE_ATTRIBUTES.neckLength;\n  const rawSpine = attributes.torsoLength / REFERENCE_ATTRIBUTES.torsoLength;\n  const rawArm = attributes.armLength / REFERENCE_ATTRIBUTES.armLength;\n  const rawLeg = attributes.legLength / REFERENCE_ATTRIBUTES.legLength;\n  const rawShoulder =\n    attributes.shoulderWidth / REFERENCE_ATTRIBUTES.shoulderWidth;\n\n  // Apply visual amplification for more noticeable archetype differences\n  // Overall height scaling is kept subtle (1.5x) for realism\n  const overall = 1.0 + (rawOverall - 1.0) * 1.5;\n\n  // Head, neck, and body proportions are amplified for visual distinction\n  const head = amplifyScaling(rawHead);\n  const neck = amplifyScaling(rawNeck);\n  const spine = amplifyScaling(rawSpine);\n\n  // Limb proportions amplified for noticeable reach differences\n  const upperArm = amplifyScaling(rawArm);\n  const forearm = amplifyScaling(rawArm);\n  const thigh = amplifyScaling(rawLeg);\n  const shin = amplifyScaling(rawLeg);\n\n  // Shoulder width amplified for body silhouette distinction\n  const shoulder = amplifyScaling(rawShoulder);\n\n  return {\n    head,\n    neck,\n    spine,\n    upperArm,\n    forearm,\n    thigh,\n    shin,\n    shoulder,\n    overall,\n  };\n}\n\n/**\n * Get scaled bone length for a specific bone.\n *\n * **Korean**: 크기 조정된 뼈 길이 (Scaled Bone Length)\n *\n * Returns the scaled length for a specific bone based on the player's\n * physical attributes. Used when creating or updating skeleton rigs.\n *\n * @param boneName - Name of the bone to scale\n * @param attributes - Player's physical attributes\n * @returns Scaled bone length in centimeters\n *\n * @example\n * ```typescript\n * const headLength = getScaledBoneLength(BoneName.HEAD, JOJIK_PHYSICAL);\n * // Jojik has larger head: returns ~23cm (base 20cm * 1.15)\n * ```\n *\n * @public\n * @korean 크기조정된뼈길이\n */\nexport function getScaledBoneLength(\n  boneName: string,\n  attributes: PhysicalAttributes,\n): number {\n  const factors = calculateBoneScalingFactors(attributes);\n\n  // Map bone names to their base dimensions and scaling factors\n  switch (boneName) {\n    // Head region\n    case BoneName.HEAD:\n      return BASE_BONE_DIMENSIONS.head * factors.head;\n    case BoneName.NECK:\n      return BASE_BONE_DIMENSIONS.neck * factors.neck;\n\n    // Spine region\n    case BoneName.SPINE_LOWER:\n      return BASE_BONE_DIMENSIONS.spineLower * factors.spine;\n    case BoneName.SPINE_MIDDLE:\n      return BASE_BONE_DIMENSIONS.spineMiddle * factors.spine;\n    case BoneName.SPINE_UPPER:\n      return BASE_BONE_DIMENSIONS.spineUpper * factors.spine;\n    case BoneName.PELVIS:\n      return BASE_BONE_DIMENSIONS.pelvis * factors.overall;\n\n    // Left arm\n    case BoneName.SHOULDER_L:\n    case BoneName.SHOULDER_R:\n      return BASE_BONE_DIMENSIONS.shoulder * factors.shoulder;\n    case BoneName.UPPER_ARM_L:\n    case BoneName.UPPER_ARM_R:\n      return BASE_BONE_DIMENSIONS.upperArm * factors.upperArm;\n    case BoneName.FOREARM_L:\n    case BoneName.FOREARM_R:\n      return BASE_BONE_DIMENSIONS.forearm * factors.forearm;\n    case BoneName.HAND_L:\n    case BoneName.HAND_R:\n      return BASE_BONE_DIMENSIONS.hand * factors.overall;\n\n    // Left leg\n    case BoneName.THIGH_L:\n    case BoneName.THIGH_R:\n      return BASE_BONE_DIMENSIONS.thigh * factors.thigh;\n    case BoneName.SHIN_L:\n    case BoneName.SHIN_R:\n      return BASE_BONE_DIMENSIONS.shin * factors.shin;\n    case BoneName.FOOT_L:\n    case BoneName.FOOT_R:\n      return BASE_BONE_DIMENSIONS.foot * factors.overall;\n\n    // Default: use overall scaling\n    default:\n      return 10 * factors.overall; // Default bone length\n  }\n}\n\n/**\n * Calculate scaled shoulder offset for skeleton positioning.\n *\n * **Korean**: 어깨 오프셋 계산 (Shoulder Offset Calculation)\n *\n * Determines the horizontal offset for shoulder bones based on\n * shoulder width. Used to position arms correctly on the skeleton.\n *\n * Applies amplification to shoulder width for more noticeable silhouette\n * differences between archetypes:\n * - Jojik (54cm): Offset = 31.05cm (54/2 * 1.15) - WIDE, imposing\n * - Hacker (43cm): Offset = 24.73cm (43/2 * 1.15) - NARROW, compact\n * - Difference: 26% wider shoulder span for visual distinction\n *\n * @param attributes - Player's physical attributes\n * @returns Shoulder offset in centimeters (half of total shoulder width, amplified)\n *\n * @example\n * ```typescript\n * const offset = calculateShoulderOffset(JOJIK_PHYSICAL);\n * // Jojik has wide shoulders: returns ~31cm (54cm width / 2 * 1.15)\n * // Left shoulder at -31cm, right shoulder at +31cm\n * ```\n *\n * @public\n * @korean 어깨오프셋계산\n */\nexport function calculateShoulderOffset(\n  attributes: PhysicalAttributes,\n): number {\n  // Shoulder width is the total span, so divide by 2 for offset from center\n  // Apply amplification factor for more visible width differences\n  const SHOULDER_AMPLIFICATION = 1.15;\n  return (attributes.shoulderWidth / 2) * SHOULDER_AMPLIFICATION;\n}\n\n/**\n * Calculate hitbox dimensions based on physical attributes.\n *\n * **Korean**: 히트박스 크기 계산 (Hitbox Dimension Calculation)\n *\n * Determines the bounding box dimensions for collision detection\n * and hit registration based on body proportions.\n *\n * @param attributes - Player's physical attributes\n * @returns Hitbox dimensions {width, height, depth} in centimeters\n *\n * @example\n * ```typescript\n * const hitbox = calculateHitboxDimensions(AMSALJA_PHYSICAL);\n * // Amsalja is tall and lean: {width: 40, height: 182, depth: 25}\n * ```\n *\n * @public\n * @korean 히트박스크기계산\n */\nexport function calculateHitboxDimensions(attributes: PhysicalAttributes): {\n  width: number;\n  height: number;\n  depth: number;\n} {\n  return {\n    width: attributes.shoulderWidth,\n    height: attributes.totalHeight,\n    depth: attributes.shoulderWidth * 0.5, // Approximate depth from shoulder width\n  };\n}\n\n/**\n * Calculate vital point offset adjustments based on body proportions.\n *\n * **Korean**: 급소 위치 조정 (Vital Point Position Adjustment)\n *\n * Adjusts vital point positions based on scaled skeleton dimensions.\n * Ensures vital points remain anatomically accurate for different\n * body types while maintaining Korean anatomy principles.\n *\n * @param vitalPointId - ID of the vital point to adjust\n * @param attributes - Player's physical attributes\n * @returns Position adjustment {x, y} offset in centimeters\n *\n * @example\n * ```typescript\n * const adjustment = calculateVitalPointAdjustment(\"head_temple\", MUSA_PHYSICAL);\n * // Returns offset based on head size and torso height\n * ```\n *\n * @public\n * @korean 급소위치조정\n */\nexport function calculateVitalPointAdjustment(\n  vitalPointId: string,\n  attributes: PhysicalAttributes,\n): { x: number; y: number } {\n  const factors = calculateBoneScalingFactors(attributes);\n\n  // Determine which body region this vital point belongs to\n  // Use exact prefix matching to avoid ambiguity\n  if (vitalPointId.startsWith(\"head_\")) {\n    // Head vital points scale with head size and torso height\n    return {\n      x: 0,\n      y: (factors.head - 1.0) * 20 + (factors.spine - 1.0) * 60,\n    };\n  } else if (vitalPointId.startsWith(\"neck_\")) {\n    // Neck vital points scale with neck length and torso height\n    return {\n      x: 0,\n      y: (factors.neck - 1.0) * 10 + (factors.spine - 1.0) * 60,\n    };\n  } else if (vitalPointId.startsWith(\"torso_\")) {\n    // Torso vital points scale with torso length\n    return {\n      x: 0,\n      y: (factors.spine - 1.0) * 30,\n    };\n  } else if (\n    vitalPointId.startsWith(\"shoulder_\") ||\n    vitalPointId.startsWith(\"arm_\")\n  ) {\n    // Arm vital points scale with arm length and shoulder width\n    return {\n      x: (factors.shoulder - 1.0) * 15,\n      y: (factors.upperArm - 1.0) * 12,\n    };\n  } else if (\n    vitalPointId.startsWith(\"leg_\") ||\n    vitalPointId.startsWith(\"knee_\")\n  ) {\n    // Leg vital points scale with leg length\n    return {\n      x: 0,\n      y: -(factors.thigh - 1.0) * 15,\n    };\n  }\n\n  // Default: no adjustment\n  return { x: 0, y: 0 };\n}\n\n/**\n * Calculate choke effectiveness modifier based on neck dimensions.\n *\n * **Korean**: 목 조르기 효과 계산 (Choke Effectiveness Calculation)\n *\n * Determines how effective chokes and strangles are based on neck\n * length and thickness. Longer, thinner necks are more vulnerable.\n *\n * @param attributes - Player's physical attributes\n * @returns Choke effectiveness multiplier (1.0 = baseline)\n *\n * @example\n * ```typescript\n * const chokeEffectiveness = calculateChokeEffectiveness(AMSALJA_PHYSICAL);\n * // Amsalja has longer neck: returns ~1.1 (10% more vulnerable)\n *\n * const jojikChoke = calculateChokeEffectiveness(JOJIK_PHYSICAL);\n * // Jojik has shorter, thicker neck: returns ~0.9 (10% more resistant)\n * ```\n *\n * @public\n * @korean 목조르기효과계산\n */\nexport function calculateChokeEffectiveness(\n  attributes: PhysicalAttributes,\n): number {\n  // Longer necks are more vulnerable to chokes\n  const lengthFactor = attributes.neckLength / REFERENCE_ATTRIBUTES.neckLength;\n\n  // Thicker necks (from muscle/weight) resist chokes better\n  const thicknessFactor = REFERENCE_ATTRIBUTES.weight / attributes.weight;\n\n  // Combine factors: longer neck + lighter weight = more vulnerable\n  return lengthFactor * thicknessFactor;\n}\n\n/**\n * Calculate head strike vulnerability based on head size.\n *\n * **Korean**: 머리 타격 취약성 계산 (Head Strike Vulnerability)\n *\n * Determines vulnerability to head strikes based on head size.\n * Larger heads have more mass and resistance, smaller heads are\n * more vulnerable to concussive force.\n *\n * @param attributes - Player's physical attributes\n * @returns Head strike vulnerability multiplier (1.0 = baseline)\n *\n * @example\n * ```typescript\n * const headVuln = calculateHeadStrikeVulnerability(JOJIK_PHYSICAL);\n * // Jojik has larger head: returns ~0.95 (5% more resistant)\n * ```\n *\n * @public\n * @korean 머리타격취약성계산\n */\nexport function calculateHeadStrikeVulnerability(\n  attributes: PhysicalAttributes,\n): number {\n  // Larger heads have more mass, providing some protection\n  const sizeFactor = REFERENCE_ATTRIBUTES.headSize / attributes.headSize;\n\n  // But larger heads are also bigger targets (handled by hitbox size)\n  // Here we only calculate the mass-based resistance\n  return sizeFactor;\n}\n\n/**\n * Calculate body radius for hit distance calculation.\n *\n * **Korean**: 몸체 반경 계산 (Body Radius Calculation)\n *\n * When calculating hit distance, we measure center-to-center, but attacks\n * land on the target's body surface. This function calculates the effective\n * \"depth\" of a fighter's body from their center point based on their\n * physical attributes.\n *\n * The calculation uses torso depth derived from shoulder width, as broader\n * fighters have proportionally deeper torsos. This is more anatomically\n * accurate than using a fixed constant.\n *\n * Formula: shoulderWidth * 0.5 (torso depth ratio) / 100 (cm to meters)\n *\n * Example body radii:\n * - Hacker (43cm shoulders): 0.215m depth → 0.215m radius\n * - Musa (46cm shoulders): 0.23m depth → 0.23m radius\n * - Jojik (54cm shoulders): 0.27m depth → 0.27m radius\n *\n * @param attributes - Player's physical attributes\n * @returns Body radius in meters (distance from center to body surface)\n *\n * @example\n * ```typescript\n * const radius = calculateBodyRadius(JOJIK_PHYSICAL);\n * // Jojik has wide shoulders (54cm): returns 0.27m\n *\n * const hackerRadius = calculateBodyRadius(HACKER_PHYSICAL);\n * // Hacker is lean (43cm shoulders): returns 0.215m\n * ```\n *\n * @public\n * @korean 몸체반경계산\n */\nexport function calculateBodyRadius(attributes: PhysicalAttributes): number {\n  // Body depth is approximately half of shoulder width (anatomical ratio)\n  // This matches calculateHitboxDimensions which uses shoulderWidth * 0.5\n  const bodyDepthCm = attributes.shoulderWidth * 0.5;\n\n  // Convert from centimeters to meters\n  // The radius is the distance from center to body surface (half of total depth)\n  // Since bodyDepthCm represents front-to-back depth, we use it directly as\n  // the distance from center to front surface\n  return bodyDepthCm / 100;\n}\n"],"mappings":";;CAiJiD,EAC/C,GAAG,wBACJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuYD,SAAgB,oBAAoB,YAAwC;AAS1E,QANoB,WAAW,gBAAgB,KAM1B"}