blacktrigram 0.7.2

package/lib/systems/movement/helpers/accelerationUtils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"accelerationUtils.js","names":[],"sources":["../../../../src/systems/movement/helpers/accelerationUtils.ts"],"sourcesContent":["/**\n * Acceleration Utilities for Movement System\n *\n * Pure functions for calculating acceleration-based running speeds.\n * Extracted for testability and reusability across training and combat screens.\n *\n * @module systems/movement/helpers/accelerationUtils\n * @category Movement\n * @korean 가속 유틸리티\n */\n\n/**\n * Step distance thresholds for foot laterality alternation\n * 발 측면성 교대를 위한 걸음 거리 임계값\n */\nexport const STEP_DISTANCE_THRESHOLDS = {\n  /**\n   * Average step length when walking (meters)\n   * 걷기 시 평균 걸음 길이\n   */\n  WALK: 0.7,\n\n  /**\n   * Average step length when running (meters)\n   * 달리기 시 평균 걸음 길이\n   */\n  RUN: 1.0,\n} as const;\n\n/**\n * Constants for acceleration-based running (defaults for non-archetype usage)\n */\nexport const ACCELERATION_CONSTANTS = {\n  /** Default walking speed in m/s (when no archetype speed provided) */\n  DEFAULT_WALK_SPEED: 6.0,\n  /** Default running speed in m/s (when no archetype speed provided) */\n  DEFAULT_RUN_SPEED: 10.0,\n  /** Time to reach running speed in seconds */\n  TIME_TO_RUN: 1.5,\n  /** Threshold for considering direction \"same\" (cos(45°) = √2/2) */\n  DIRECTION_THRESHOLD: Math.cos(Math.PI / 4),\n  /** Running threshold as percentage of max speed (0-1) */\n  RUN_THRESHOLD_PERCENT: 0.9,\n  /** Epsilon for speed change detection (m/s) */\n  SPEED_CHANGE_EPSILON: 0.05,\n} as const;\n\n/**\n * Calculate running threshold speed\n * @param runSpeed - Maximum running speed (from archetype or default)\n * @returns Speed at which movement is considered running (m/s)\n */\nexport function calculateRunThreshold(\n  runSpeed: number = ACCELERATION_CONSTANTS.DEFAULT_RUN_SPEED\n): number {\n  return runSpeed * ACCELERATION_CONSTANTS.RUN_THRESHOLD_PERCENT;\n}\n\n/**\n * Check if two directions are consistent (within threshold angle)\n * @param currentDir Current direction vector\n * @param lastDir Previous direction vector\n * @returns True if directions are within 45° of each other\n */\nexport function isDirectionConsistent(\n  currentDir: { x: number; y: number },\n  lastDir: { x: number; y: number }\n): boolean {\n  // If last direction is zero, consider any movement as consistent\n  if (lastDir.x === 0 && lastDir.y === 0) {\n    return true;\n  }\n\n  // Calculate dot product\n  const dot = currentDir.x * lastDir.x + currentDir.y * lastDir.y;\n  const magCurrent = Math.sqrt(currentDir.x ** 2 + currentDir.y ** 2);\n  const magLast = Math.sqrt(lastDir.x ** 2 + lastDir.y ** 2);\n\n  if (magCurrent === 0 || magLast === 0) {\n    return false;\n  }\n\n  // Clamp cosAngle to [-1, 1] to handle floating-point edge cases\n  const cosAngleRaw = dot / (magCurrent * magLast);\n  const cosAngle = Math.max(-1, Math.min(1, cosAngleRaw));\n  \n  // Use >= to include exactly 45° as consistent (not trigger reset)\n  return cosAngle >= ACCELERATION_CONSTANTS.DIRECTION_THRESHOLD;\n}\n\n/**\n * Calculate acceleration-based speed\n * @param movementTime Accumulated movement time in same direction (seconds)\n * @param walkSpeed - Walking speed in m/s (from archetype or default)\n * @param runSpeed - Running speed in m/s (from archetype or default)\n * @returns Interpolated speed between walk and run (m/s)\n */\nexport function calculateAcceleratedSpeed(\n  movementTime: number,\n  walkSpeed: number = ACCELERATION_CONSTANTS.DEFAULT_WALK_SPEED,\n  runSpeed: number = ACCELERATION_CONSTANTS.DEFAULT_RUN_SPEED\n): number {\n  const progress = Math.min(movementTime / ACCELERATION_CONSTANTS.TIME_TO_RUN, 1.0);\n  return walkSpeed + (runSpeed - walkSpeed) * progress;\n}\n\n/**\n * Check if speed change is meaningful (exceeds epsilon)\n * @param oldSpeed Previous speed (m/s)\n * @param newSpeed New speed (m/s)\n * @returns True if change exceeds threshold\n */\nexport function isSpeedChangeMeaningful(oldSpeed: number, newSpeed: number): boolean {\n  return Math.abs(newSpeed - oldSpeed) >= ACCELERATION_CONSTANTS.SPEED_CHANGE_EPSILON;\n}\n\n/**\n * Determine if player is running based on current speed\n * @param speed Current speed (m/s)\n * @param runSpeed - Maximum running speed (from archetype or default)\n * @returns True if speed exceeds running threshold\n */\nexport function isRunningSpeed(\n  speed: number,\n  runSpeed: number = ACCELERATION_CONSTANTS.DEFAULT_RUN_SPEED\n): boolean {\n  return speed >= calculateRunThreshold(runSpeed);\n}\n"],"mappings":";;;;;;;;;;;;;;;AAeA,IAAa,2BAA2B;CAKtC,MAAM;CAMN,KAAK;CACN;;;;AAKD,IAAa,yBAAyB;CAEpC,oBAAoB;CAEpB,mBAAmB;CAEnB,aAAa;CAEb,qBAAqB,KAAK,IAAI,KAAK,KAAK,EAAE;CAE1C,uBAAuB;CAEvB,sBAAsB;CACvB;;;;;;AAOD,SAAgB,sBACd,WAAmB,uBAAuB,mBAClC;AACR,QAAO,WAAW,uBAAuB;;;;;;;;AAS3C,SAAgB,sBACd,YACA,SACS;AAET,KAAI,QAAQ,MAAM,KAAK,QAAQ,MAAM,EACnC,QAAO;CAIT,MAAM,MAAM,WAAW,IAAI,QAAQ,IAAI,WAAW,IAAI,QAAQ;CAC9D,MAAM,aAAa,KAAK,KAAK,WAAW,KAAK,IAAI,WAAW,KAAK,EAAE;CACnE,MAAM,UAAU,KAAK,KAAK,QAAQ,KAAK,IAAI,QAAQ,KAAK,EAAE;AAE1D,KAAI,eAAe,KAAK,YAAY,EAClC,QAAO;CAIT,MAAM,cAAc,OAAO,aAAa;AAIxC,QAHiB,KAAK,IAAI,IAAI,KAAK,IAAI,GAAG,YAAY,CAAC,IAGpC,uBAAuB;;;;;;;;;AAU5C,SAAgB,0BACd,cACA,YAAoB,uBAAuB,oBAC3C,WAAmB,uBAAuB,mBAClC;CACR,MAAM,WAAW,KAAK,IAAI,eAAe,uBAAuB,aAAa,EAAI;AACjF,QAAO,aAAa,WAAW,aAAa;;;;;;;;AAS9C,SAAgB,wBAAwB,UAAkB,UAA2B;AACnF,QAAO,KAAK,IAAI,WAAW,SAAS,IAAI,uBAAuB;;;;;;;;AASjE,SAAgB,eACd,OACA,WAAmB,uBAAuB,mBACjC;AACT,QAAO,SAAS,sBAAsB,SAAS"}

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

@@ -0,0 +1,16 @@
+/**
+ * Movement System Module
+ *
+ * **Korean**: 이동 시스템 (Movement System)
+ *
+ * Exports for the injury-based movement system including modifiers,
+ * integration helpers, and type definitions.
+ *
+ * @module systems/movement
+ * @category Movement System
+ * @korean 이동시스템
+ */
+export { InjuryMovementModifier, DEFAULT_INJURY_MOVEMENT_CONFIG, type InjuryMovementConfig, type PartialInjuryMovementConfig, type InjuryMovementResult, injuryMovementModifier, } from "./InjuryMovementModifier";
+export { calculateLegInjuryFactor, calculateMovementSpeed, calculateInjuryMultiplier, } from "./integration";
+export { STANCE_SPEED_MODIFIERS } from "../physics/MovementPhysics";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/systems/movement/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EACL,sBAAsB,EACtB,8BAA8B,EAC9B,KAAK,oBAAoB,EACzB,KAAK,2BAA2B,EAChC,KAAK,oBAAoB,EACzB,sBAAsB,GACvB,MAAM,0BAA0B,CAAC;AAElC,OAAO,EACL,wBAAwB,EACxB,sBAAsB,EACtB,yBAAyB,GAC1B,MAAM,eAAe,CAAC;AAGvB,OAAO,EAAE,sBAAsB,EAAE,MAAM,4BAA4B,CAAC"}

package/lib/systems/movement/integration.d.ts

@@ -0,0 +1,91 @@
+/**
+ * Integration module for InjuryMovementModifier with MovementPhysics
+ *
+ * **Korean**: 손상 이동 통합 (Injury Movement Integration)
+ *
+ * Provides helper functions to integrate the InjuryMovementModifier system
+ * with the existing MovementPhysics system.
+ *
+ * @module systems/movement/integration
+ * @category Movement System
+ * @korean 손상이동통합
+ */
+import type { BodyPartHealth } from "../bodypart/types";
+import { TrigramStance } from "../../types/common";
+/**
+ * Calculate leg injury factor for MovementPhysics from body part health.
+ *
+ * **Korean**: 다리 손상 요소 계산
+ *
+ * Converts detailed body part health into a simple 0-1 injury factor
+ * that MovementPhysics.MovementState expects. This allows gradual
+ * migration from the old simple system to the new detailed system.
+ *
+ * Uses the **worst** (minimum) leg health to match the main injury system's behavior,
+ * ensuring asymmetric injuries (e.g., one leg at 0%, other at 100%) are properly represented.
+ *
+ * @param bodyPartHealth - Current body part health
+ * @returns Leg injury factor (0 = healthy, 1 = fully injured), clamped to 0-1 range
+ *
+ * @example
+ * ```typescript
+ * const legInjuryFactor = calculateLegInjuryFactor(bodyPartHealth);
+ * movementState.legInjuryFactor = legInjuryFactor;
+ * ```
+ *
+ * @public
+ * @korean 다리손상요소계산
+ */
+export declare function calculateLegInjuryFactor(bodyPartHealth: BodyPartHealth): number;
+/**
+ * Calculate comprehensive movement speed with all injury modifiers.
+ *
+ * **Korean**: 종합 이동 속도 계산
+ *
+ * This is the recommended function for full integration with the new
+ * injury system. It applies all modifiers including leg injuries,
+ * torso damage, stance bonuses, and pain penalties.
+ *
+ * Uses the shared singleton instance to avoid allocations in per-frame loops.
+ *
+ * @param baseSpeed - Base movement speed (m/s)
+ * @param bodyPartHealth - Current body part health
+ * @param stance - Current trigram stance
+ * @param painLevel - Current pain level (0-100)
+ * @returns Final calculated speed in m/s
+ *
+ * @example
+ * ```typescript
+ * const finalSpeed = calculateMovementSpeed(
+ *   5.0,
+ *   playerBodyHealth,
+ *   TrigramStance.GEON,
+ *   65
+ * );
+ *
+ * // Use this speed to override MovementPhysics
+ * movementPhysics.setMaxSpeed(finalSpeed);
+ * ```
+ *
+ * @public
+ * @korean 종합이동속도계산
+ */
+export declare function calculateMovementSpeed(baseSpeed: number, bodyPartHealth: BodyPartHealth, stance: TrigramStance, painLevel: number): number;
+/**
+ * Calculate speed multiplier from injuries (without stance or pain).
+ *
+ * **Korean**: 손상 속도 배수 계산
+ *
+ * Useful when you want to apply injury penalties separately from
+ * stance and pain modifiers.
+ *
+ * Uses the shared singleton instance to avoid allocations in per-frame loops.
+ *
+ * @param bodyPartHealth - Current body part health
+ * @returns Speed multiplier (0.1-1.0)
+ *
+ * @public
+ * @korean 손상속도배수계산
+ */
+export declare function calculateInjuryMultiplier(bodyPartHealth: BodyPartHealth): number;
+//# sourceMappingURL=integration.d.ts.map

package/lib/systems/movement/integration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"integration.d.ts","sourceRoot":"","sources":["../../../src/systems/movement/integration.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAGH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACxD,OAAO,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAE/C;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,wBAAwB,CACtC,cAAc,EAAE,cAAc,GAC7B,MAAM,CAeR;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,sBAAsB,CACpC,SAAS,EAAE,MAAM,EACjB,cAAc,EAAE,cAAc,EAC9B,MAAM,EAAE,aAAa,EACrB,SAAS,EAAE,MAAM,GAChB,MAAM,CASR;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,yBAAyB,CACvC,cAAc,EAAE,cAAc,GAC7B,MAAM,CAWR"}

package/lib/systems/physics/AttackMovementPhysics.d.ts

@@ -0,0 +1,283 @@
+/**
+ * Attack Movement Physics System for realistic forward momentum during attacks.
+ *
+ * **Korean**: 공격 이동 물리 시스템 (Attack Movement Physics System)
+ *
+ * Implements realistic forward movement physics when fighters execute attacks.
+ * Kicks naturally extend the body forward, punches lunge with body weight,
+ * and spinning techniques carry rotational momentum.
+ *
+ * ## Attack Movement Mechanics
+ *
+ * Forward movement distance is determined by:
+ * - Animation type (kicks > punches > elbows/knees)
+ * - Stance modifiers (8 trigram stances affect aggression)
+ * - Animation phase timing (extension → peak → recovery)
+ *
+ * ## Movement Integration
+ *
+ * - Extension phase (frames 3-6): Forward lunge with ease-out
+ * - Peak phase (frame 6): Maximum extension reached
+ * - Recovery phase (frames 7-10): Return to original stance
+ * - Arena bounds: Automatically clamp movement to valid zone
+ *
+ * ## Performance
+ *
+ * Optimized for 60fps with efficient vector calculations and
+ * smooth easing curves for realistic attack momentum feel.
+ *
+ * @module systems/physics/AttackMovementPhysics
+ * @category Physics System
+ * @korean 공격이동물리
+ */
+import * as THREE from "three";
+import { TrigramStance } from "../../types/common";
+import { AnimationType } from "../animation";
+/**
+ * Configuration for attack movement calculation.
+ *
+ * **Korean**: 공격 이동 설정 (Attack Movement Configuration)
+ *
+ * @public
+ * @korean 공격이동설정
+ */
+export interface AttackMovementConfig {
+    /** Animation type being executed */
+    readonly animationType: AnimationType;
+    /** Current trigram stance */
+    readonly currentStance: TrigramStance;
+    /** Normalized attack direction vector (attacker → target) */
+    readonly direction: THREE.Vector3;
+    /** Total attack animation duration in seconds */
+    readonly animationDuration: number;
+}
+/**
+ * Result of attack movement calculation.
+ *
+ * **Korean**: 공격 이동 결과 (Attack Movement Result)
+ *
+ * Contains displacement vector and timing for attack lunge.
+ *
+ * @public
+ * @korean 공격이동결과
+ */
+export interface AttackMovementResult {
+    /** Total forward displacement vector in world space */
+    readonly displacement: THREE.Vector3;
+    /** Duration of forward lunge phase in seconds */
+    readonly lungeDuration: number;
+    /** Duration of recovery return phase in seconds */
+    readonly recoveryDuration: number;
+    /** Total movement cycle duration in seconds */
+    readonly totalDuration: number;
+}
+/**
+ * Attack Movement Physics Engine.
+ *
+ * **Korean**: 공격 이동 물리 엔진
+ *
+ * Calculates realistic forward movement during attack animations
+ * based on technique type, stance modifiers, and animation timing.
+ * Provides smooth lunge and recovery phases for authentic martial arts feel.
+ *
+ * @example
+ * ```typescript
+ * const physics = new AttackMovementPhysics();
+ *
+ * // Calculate movement for roundhouse kick
+ * const config: AttackMovementConfig = {
+ *   animationType: AnimationType.ROUNDHOUSE_KICK,
+ *   currentStance: TrigramStance.LI, // Fire stance (aggressive)
+ *   direction: new THREE.Vector3(1, 0, 0).normalize(),
+ *   animationDuration: 0.48, // 480ms kick animation
+ * };
+ *
+ * const result = physics.calculateAttackMovement(config);
+ * // Result: 1.0m base * 1.3 (Fire bonus) = ~1.3m forward lunge
+ * // lungeDuration: 0.24s (50% of animation)
+ * // recoveryDuration: 0.24s (50% of animation)
+ * ```
+ *
+ * @public
+ * @korean 공격이동물리
+ */
+export declare class AttackMovementPhysics {
+    /**
+     * Calculates attack movement displacement and timing.
+     *
+     * **Korean**: 공격 이동 계산 (Calculate Attack Movement)
+     *
+     * Determines forward lunge distance and recovery timing based on:
+     * 1. Base movement from animation type
+     * 2. Stance movement modifier (8 trigram effects)
+     * 3. Animation phase durations (lunge vs recovery)
+     *
+     * @param config - Attack movement configuration
+     * @returns Attack movement result with displacement and timing
+     *
+     * @example
+     * ```typescript
+     * // Front kick with Heaven stance
+     * const kick = physics.calculateAttackMovement({
+     *   animationType: AnimationType.FRONT_KICK,
+     *   currentStance: TrigramStance.GEON,
+     *   direction: attackVector,
+     *   animationDuration: 0.4,
+     * });
+     * // Result: ~0.88m forward (0.8m * 1.1 Geon modifier)
+     *
+     * // Jab with Mountain stance
+     * const jab = physics.calculateAttackMovement({
+     *   animationType: AnimationType.JAB,
+     *   currentStance: TrigramStance.GAN,
+     *   direction: attackVector,
+     *   animationDuration: 0.25,
+     * });
+     * // Result: ~0.24m forward (0.3m * 0.8 Gan modifier)
+     * ```
+     *
+     * @public
+     * @korean 공격이동계산
+     */
+    calculateAttackMovement(config: AttackMovementConfig): AttackMovementResult;
+    /**
+     * Gets base forward movement distance for animation type.
+     *
+     * **Korean**: 기본 이동 거리 (Base Movement Distance)
+     *
+     * Movement distances by technique category:
+     * - Kicks: 0.8-1.2m (leg extension, longest reach)
+     * - Punches: 0.3-0.5m (arm extension, body lunge)
+     * - Elbows/Knees: 0.2-0.3m (close range techniques)
+     * - Spinning: 0.5-0.8m (rotation carries momentum)
+     *
+     * @param animationType - Type of attack animation
+     * @returns Base movement distance in meters
+     *
+     * @private
+     * @korean 기본이동거리
+     */
+    private getBaseMovementDistance;
+    /**
+     * Gets stance movement modifier for attack lunge.
+     *
+     * **Korean**: 자세 이동 배율 (Stance Movement Modifier)
+     *
+     * Trigram stance movement modifiers based on combat philosophy:
+     * - ☰ 건 (Geon/Heaven): +30% movement (aggressive, drives forward with pure yang)
+     * - ☳ 진 (Jin/Thunder): +20% movement (explosive power, shocking force)
+     * - ☴ 손 (Son/Wind): +15% movement (continuous flow, mobile)
+     * - ☲ 리 (Li/Fire): +10% movement (precision strikes, controlled aggression)
+     * - ☱ 태 (Tae/Lake): 0% (neutral, fluid and adaptive)
+     * - ☵ 감 (Gam/Water): 0% (neutral, flowing and flexible)
+     * - ☷ 곤 (Gon/Earth): -10% movement (grounded, stable techniques)
+     * - ☶ 간 (Gan/Mountain): -20% movement (defensive mastery, minimal advance)
+     *
+     * @param stance - Current trigram stance
+     * @returns Movement multiplier (0.8 to 1.3)
+     *
+     * @private
+     * @korean 자세이동배율
+     */
+    private getStanceMovementModifier;
+    /**
+     * Applies attack movement force to attacker position over time.
+     *
+     * **Korean**: 공격 이동 적용 (Apply Attack Movement)
+     *
+     * Uses smooth ease-out cubic curve for realistic lunge feel:
+     * - Fast initial forward movement (attack commitment)
+     * - Gradual deceleration at peak extension
+     * - Smooth return during recovery phase
+     *
+     * @param basePosition - Original stance position (does not change during attack)
+     * @param result - Attack movement result with displacement
+     * @param elapsedTime - Time elapsed since attack started
+     * @param isRecoveryPhase - Whether in recovery (return) phase
+     * @returns New position with attack displacement applied
+     *
+     * @example
+     * ```typescript
+     * // In animation update loop (60fps)
+     * const basePos = new THREE.Vector3(0, 0, 0); // Original stance position
+     *
+     * if (elapsedTime < result.lungeDuration) {
+     *   // Lunge forward phase
+     *   const newPosition = physics.applyAttackMovement(
+     *     basePos,
+     *     result,
+     *     elapsedTime,
+     *     false
+     *   );
+     * } else if (elapsedTime < result.totalDuration) {
+     *   // Recovery return phase
+     *   const newPosition = physics.applyAttackMovement(
+     *     basePos,
+     *     result,
+     *     elapsedTime,
+     *     true
+     *   );
+     * }
+     * ```
+     *
+     * @public
+     * @korean 공격이동적용
+     */
+    applyAttackMovement(basePosition: THREE.Vector3, result: AttackMovementResult, elapsedTime: number, isRecoveryPhase: boolean): THREE.Vector3;
+    /**
+     * Checks if attacker is currently in lunge phase.
+     *
+     * **Korean**: 돌진 상태 확인 (Check Lunge State)
+     *
+     * @param elapsedTime - Time elapsed since attack started
+     * @param lungeDuration - Total lunge phase duration
+     * @returns True if in forward lunge phase
+     *
+     * @public
+     * @korean 돌진상태확인
+     */
+    isInLungePhase(elapsedTime: number, lungeDuration: number): boolean;
+    /**
+     * Checks if attacker is in recovery return phase.
+     *
+     * **Korean**: 회복 상태 확인 (Check Recovery State)
+     *
+     * @param elapsedTime - Time elapsed since attack started
+     * @param result - Attack movement result with timing
+     * @returns True if in recovery return phase
+     *
+     * @public
+     * @korean 회복상태확인
+     */
+    isInRecoveryPhase(elapsedTime: number, result: AttackMovementResult): boolean;
+    /**
+     * Gets bilingual Korean-English name for lunge phase.
+     *
+     * **Korean**: 돌진 단계 이름 (Lunge Phase Name)
+     *
+     * @returns Korean and English phase names
+     *
+     * @public
+     * @korean 돌진단계이름
+     */
+    getLungePhaseName(): {
+        korean: string;
+        english: string;
+    };
+    /**
+     * Gets bilingual Korean-English name for recovery phase.
+     *
+     * **Korean**: 복귀 단계 이름 (Recovery Phase Name)
+     *
+     * @returns Korean and English phase names
+     *
+     * @public
+     * @korean 복귀단계이름
+     */
+    getRecoveryPhaseName(): {
+        korean: string;
+        english: string;
+    };
+}
+export default AttackMovementPhysics;
+//# sourceMappingURL=AttackMovementPhysics.d.ts.map

package/lib/systems/physics/AttackMovementPhysics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AttackMovementPhysics.d.ts","sourceRoot":"","sources":["../../../src/systems/physics/AttackMovementPhysics.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAC/C,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEpD;;;;;;;GAOG;AACH,MAAM,WAAW,oBAAoB;IACnC,oCAAoC;IACpC,QAAQ,CAAC,aAAa,EAAE,aAAa,CAAC;IACtC,6BAA6B;IAC7B,QAAQ,CAAC,aAAa,EAAE,aAAa,CAAC;IACtC,6DAA6D;IAC7D,QAAQ,CAAC,SAAS,EAAE,KAAK,CAAC,OAAO,CAAC;IAClC,iDAAiD;IACjD,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAC;CACpC;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,oBAAoB;IACnC,uDAAuD;IACvD,QAAQ,CAAC,YAAY,EAAE,KAAK,CAAC,OAAO,CAAC;IACrC,iDAAiD;IACjD,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,mDAAmD;IACnD,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC,+CAA+C;IAC/C,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;CAChC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,qBAAa,qBAAqB;IAChC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAoCG;IACH,uBAAuB,CACrB,MAAM,EAAE,oBAAoB,GAC3B,oBAAoB;IAuBvB;;;;;;;;;;;;;;;;OAgBG;IACH,OAAO,CAAC,uBAAuB;IAqJ/B;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,OAAO,CAAC,yBAAyB;IAcjC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA0CG;IACH,mBAAmB,CACjB,YAAY,EAAE,KAAK,CAAC,OAAO,EAC3B,MAAM,EAAE,oBAAoB,EAC5B,WAAW,EAAE,MAAM,EACnB,eAAe,EAAE,OAAO,GACvB,KAAK,CAAC,OAAO;IAmChB;;;;;;;;;;;OAWG;IACH,cAAc,CAAC,WAAW,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,OAAO;IAInE;;;;;;;;;;;OAWG;IACH,iBAAiB,CACf,WAAW,EAAE,MAAM,EACnB,MAAM,EAAE,oBAAoB,GAC3B,OAAO;IAOV;;;;;;;;;OASG;IACH,iBAAiB,IAAI;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE;IAOxD;;;;;;;;;OASG;IACH,oBAAoB,IAAI;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE;CAM5D;AAED,eAAe,qBAAqB,CAAC"}

package/lib/systems/physics/AttackMovementPhysics.js

@@ -0,0 +1,272 @@
+import { TrigramStance } from "../../types/common.js";
+import { AnimationType } from "../animation/builders/MartialArtsConstants.js";
+import "../animation/index.js";
+//#region src/systems/physics/AttackMovementPhysics.ts
+/**
+* Attack Movement Physics Engine.
+*
+* **Korean**: 공격 이동 물리 엔진
+*
+* Calculates realistic forward movement during attack animations
+* based on technique type, stance modifiers, and animation timing.
+* Provides smooth lunge and recovery phases for authentic martial arts feel.
+*
+* @example
+* ```typescript
+* const physics = new AttackMovementPhysics();
+*
+* // Calculate movement for roundhouse kick
+* const config: AttackMovementConfig = {
+*   animationType: AnimationType.ROUNDHOUSE_KICK,
+*   currentStance: TrigramStance.LI, // Fire stance (aggressive)
+*   direction: new THREE.Vector3(1, 0, 0).normalize(),
+*   animationDuration: 0.48, // 480ms kick animation
+* };
+*
+* const result = physics.calculateAttackMovement(config);
+* // Result: 1.0m base * 1.3 (Fire bonus) = ~1.3m forward lunge
+* // lungeDuration: 0.24s (50% of animation)
+* // recoveryDuration: 0.24s (50% of animation)
+* ```
+*
+* @public
+* @korean 공격이동물리
+*/
+var AttackMovementPhysics = class {
+	/**
+	* Calculates attack movement displacement and timing.
+	*
+	* **Korean**: 공격 이동 계산 (Calculate Attack Movement)
+	*
+	* Determines forward lunge distance and recovery timing based on:
+	* 1. Base movement from animation type
+	* 2. Stance movement modifier (8 trigram effects)
+	* 3. Animation phase durations (lunge vs recovery)
+	*
+	* @param config - Attack movement configuration
+	* @returns Attack movement result with displacement and timing
+	*
+	* @example
+	* ```typescript
+	* // Front kick with Heaven stance
+	* const kick = physics.calculateAttackMovement({
+	*   animationType: AnimationType.FRONT_KICK,
+	*   currentStance: TrigramStance.GEON,
+	*   direction: attackVector,
+	*   animationDuration: 0.4,
+	* });
+	* // Result: ~0.88m forward (0.8m * 1.1 Geon modifier)
+	*
+	* // Jab with Mountain stance
+	* const jab = physics.calculateAttackMovement({
+	*   animationType: AnimationType.JAB,
+	*   currentStance: TrigramStance.GAN,
+	*   direction: attackVector,
+	*   animationDuration: 0.25,
+	* });
+	* // Result: ~0.24m forward (0.3m * 0.8 Gan modifier)
+	* ```
+	*
+	* @public
+	* @korean 공격이동계산
+	*/
+	calculateAttackMovement(config) {
+		const finalDistance = this.getBaseMovementDistance(config.animationType) * this.getStanceMovementModifier(config.currentStance);
+		return {
+			displacement: config.direction.clone().multiplyScalar(finalDistance),
+			lungeDuration: config.animationDuration * .5,
+			recoveryDuration: config.animationDuration * .5,
+			totalDuration: config.animationDuration
+		};
+	}
+	/**
+	* Gets base forward movement distance for animation type.
+	*
+	* **Korean**: 기본 이동 거리 (Base Movement Distance)
+	*
+	* Movement distances by technique category:
+	* - Kicks: 0.8-1.2m (leg extension, longest reach)
+	* - Punches: 0.3-0.5m (arm extension, body lunge)
+	* - Elbows/Knees: 0.2-0.3m (close range techniques)
+	* - Spinning: 0.5-0.8m (rotation carries momentum)
+	*
+	* @param animationType - Type of attack animation
+	* @returns Base movement distance in meters
+	*
+	* @private
+	* @korean 기본이동거리
+	*/
+	getBaseMovementDistance(animationType) {
+		if (animationType === AnimationType.ROUNDHOUSE_KICK || animationType === AnimationType.SIDE_KICK || animationType === AnimationType.BACK_KICK) return 1;
+		if (animationType === AnimationType.FRONT_KICK || animationType === AnimationType.PUSH_KICK) return .8;
+		if (animationType === AnimationType.AXE_KICK || animationType === AnimationType.CRESCENT_KICK || animationType === AnimationType.LOW_KICK) return .9;
+		if (animationType === AnimationType.SPINNING_HOOK || animationType === AnimationType.SPINNING_HEEL_KICK || animationType === AnimationType.TORNADO_KICK) return .8;
+		if (animationType === AnimationType.FLYING_KICK || animationType === AnimationType.JUMPING_KICK) return 1.2;
+		if (animationType === AnimationType.CROSS || animationType === AnimationType.OVERHAND || animationType === AnimationType.HOOK) return .5;
+		if (animationType === AnimationType.JAB || animationType === AnimationType.BACKFIST) return .3;
+		if (animationType === AnimationType.UPPERCUT || animationType === AnimationType.HAMMER_FIST || animationType === AnimationType.PALM_STRIKE) return .4;
+		if (animationType === AnimationType.ELBOW_STRIKE || animationType === AnimationType.KNEE_STRIKE || animationType === AnimationType.KNEE_KICK || animationType === AnimationType.ELBOW_UPPERCUT || animationType === AnimationType.FLYING_KNEE || animationType === AnimationType.CLINCH_KNEE || animationType === AnimationType.SPINNING_ELBOW || animationType === AnimationType.TEMPLE_ELBOW || animationType === AnimationType.SPINNING_BACK_ELBOW || animationType === AnimationType.SPINAL_ELBOW || animationType === AnimationType.BRACHIAL_ELBOW || animationType === AnimationType.KIDNEY_KNEE || animationType === AnimationType.FEMORAL_KNEE) return .2;
+		if (animationType === AnimationType.SPEAR_HAND_STRIKE || animationType === AnimationType.NERVE_STRIKE || animationType === AnimationType.PRESSURE_POINT_STRIKE || animationType === AnimationType.LIGHTNING_STRIKE || animationType === AnimationType.RAPID_BARRAGE || animationType === AnimationType.RHYTHMIC_STRIKES || animationType === AnimationType.NERVE_PARALYSIS || animationType === AnimationType.THROAT_STRIKE || animationType === AnimationType.EYE_GOUGE) return .3;
+		if (animationType === AnimationType.HEAVEN_STRIKE || animationType === AnimationType.FLOWING_CROSS) return .5;
+		if (animationType === AnimationType.SOLAR_PLEXUS_STRIKE || animationType === AnimationType.FLOWING_PUSH || animationType === AnimationType.LIVER_DISRUPTION || animationType === AnimationType.EAR_STRIKE) return .4;
+		if (animationType === AnimationType.THROW || animationType === AnimationType.JOINT_LOCK || animationType === AnimationType.TAKEDOWN || animationType === AnimationType.SWEEP || animationType === AnimationType.CLINCH || animationType === AnimationType.GRAPPLE || animationType === AnimationType.SLAM || animationType === AnimationType.WRIST_LOCK || animationType === AnimationType.ARM_BAR || animationType === AnimationType.SHOULDER_LOCK || animationType === AnimationType.HIP_THROW || animationType === AnimationType.LEG_REAP || animationType === AnimationType.SMALL_CIRCLE_LOCK || animationType === AnimationType.FINGER_LOCK || animationType === AnimationType.ELBOW_LOCK || animationType === AnimationType.SHOULDER_MANIPULATION || animationType === AnimationType.MOUNTAIN_LOCK || animationType === AnimationType.EARTH_EMBRACE || animationType === AnimationType.CAROTID_CHOKE) return .05;
+		return .2;
+	}
+	/**
+	* Gets stance movement modifier for attack lunge.
+	*
+	* **Korean**: 자세 이동 배율 (Stance Movement Modifier)
+	*
+	* Trigram stance movement modifiers based on combat philosophy:
+	* - ☰ 건 (Geon/Heaven): +30% movement (aggressive, drives forward with pure yang)
+	* - ☳ 진 (Jin/Thunder): +20% movement (explosive power, shocking force)
+	* - ☴ 손 (Son/Wind): +15% movement (continuous flow, mobile)
+	* - ☲ 리 (Li/Fire): +10% movement (precision strikes, controlled aggression)
+	* - ☱ 태 (Tae/Lake): 0% (neutral, fluid and adaptive)
+	* - ☵ 감 (Gam/Water): 0% (neutral, flowing and flexible)
+	* - ☷ 곤 (Gon/Earth): -10% movement (grounded, stable techniques)
+	* - ☶ 간 (Gan/Mountain): -20% movement (defensive mastery, minimal advance)
+	*
+	* @param stance - Current trigram stance
+	* @returns Movement multiplier (0.8 to 1.3)
+	*
+	* @private
+	* @korean 자세이동배율
+	*/
+	getStanceMovementModifier(stance) {
+		return {
+			[TrigramStance.GEON]: 1.3,
+			[TrigramStance.JIN]: 1.2,
+			[TrigramStance.SON]: 1.15,
+			[TrigramStance.LI]: 1.1,
+			[TrigramStance.TAE]: 1,
+			[TrigramStance.GAM]: 1,
+			[TrigramStance.GON]: .9,
+			[TrigramStance.GAN]: .8
+		}[stance];
+	}
+	/**
+	* Applies attack movement force to attacker position over time.
+	*
+	* **Korean**: 공격 이동 적용 (Apply Attack Movement)
+	*
+	* Uses smooth ease-out cubic curve for realistic lunge feel:
+	* - Fast initial forward movement (attack commitment)
+	* - Gradual deceleration at peak extension
+	* - Smooth return during recovery phase
+	*
+	* @param basePosition - Original stance position (does not change during attack)
+	* @param result - Attack movement result with displacement
+	* @param elapsedTime - Time elapsed since attack started
+	* @param isRecoveryPhase - Whether in recovery (return) phase
+	* @returns New position with attack displacement applied
+	*
+	* @example
+	* ```typescript
+	* // In animation update loop (60fps)
+	* const basePos = new THREE.Vector3(0, 0, 0); // Original stance position
+	* 
+	* if (elapsedTime < result.lungeDuration) {
+	*   // Lunge forward phase
+	*   const newPosition = physics.applyAttackMovement(
+	*     basePos,
+	*     result,
+	*     elapsedTime,
+	*     false
+	*   );
+	* } else if (elapsedTime < result.totalDuration) {
+	*   // Recovery return phase
+	*   const newPosition = physics.applyAttackMovement(
+	*     basePos,
+	*     result,
+	*     elapsedTime,
+	*     true
+	*   );
+	* }
+	* ```
+	*
+	* @public
+	* @korean 공격이동적용
+	*/
+	applyAttackMovement(basePosition, result, elapsedTime, isRecoveryPhase) {
+		let progress;
+		if (!isRecoveryPhase) {
+			progress = Math.min(1, elapsedTime / result.lungeDuration);
+			const easedProgress = 1 - Math.pow(1 - progress, 3);
+			const currentDisplacement = result.displacement.clone().multiplyScalar(easedProgress);
+			return basePosition.clone().add(currentDisplacement);
+		} else {
+			const recoveryTime = elapsedTime - result.lungeDuration;
+			progress = Math.min(1, recoveryTime / result.recoveryDuration);
+			const easedProgress = Math.pow(progress, 3);
+			const returnDisplacement = result.displacement.clone().multiplyScalar(1 - easedProgress);
+			return basePosition.clone().add(returnDisplacement);
+		}
+	}
+	/**
+	* Checks if attacker is currently in lunge phase.
+	*
+	* **Korean**: 돌진 상태 확인 (Check Lunge State)
+	*
+	* @param elapsedTime - Time elapsed since attack started
+	* @param lungeDuration - Total lunge phase duration
+	* @returns True if in forward lunge phase
+	*
+	* @public
+	* @korean 돌진상태확인
+	*/
+	isInLungePhase(elapsedTime, lungeDuration) {
+		return elapsedTime < lungeDuration;
+	}
+	/**
+	* Checks if attacker is in recovery return phase.
+	*
+	* **Korean**: 회복 상태 확인 (Check Recovery State)
+	*
+	* @param elapsedTime - Time elapsed since attack started
+	* @param result - Attack movement result with timing
+	* @returns True if in recovery return phase
+	*
+	* @public
+	* @korean 회복상태확인
+	*/
+	isInRecoveryPhase(elapsedTime, result) {
+		return elapsedTime >= result.lungeDuration && elapsedTime < result.totalDuration;
+	}
+	/**
+	* Gets bilingual Korean-English name for lunge phase.
+	*
+	* **Korean**: 돌진 단계 이름 (Lunge Phase Name)
+	*
+	* @returns Korean and English phase names
+	*
+	* @public
+	* @korean 돌진단계이름
+	*/
+	getLungePhaseName() {
+		return {
+			korean: "돌진",
+			english: "Lunge"
+		};
+	}
+	/**
+	* Gets bilingual Korean-English name for recovery phase.
+	*
+	* **Korean**: 복귀 단계 이름 (Recovery Phase Name)
+	*
+	* @returns Korean and English phase names
+	*
+	* @public
+	* @korean 복귀단계이름
+	*/
+	getRecoveryPhaseName() {
+		return {
+			korean: "복귀",
+			english: "Recovery"
+		};
+	}
+};
+//#endregion
+export { AttackMovementPhysics as default };
+
+//# sourceMappingURL=AttackMovementPhysics.js.map