blacktrigram 0.7.2

package/lib/systems/animation/core/AnimationTransitions.js

@@ -0,0 +1,920 @@
+import { AnimationState, FALL_TO_GROUND_MAP } from "./types.js";
+import { TrigramStance } from "../../../types/common.js";
+//#region src/systems/animation/core/AnimationTransitions.ts
+/**
+* Stance guard animation states (팔괘 방어 자세)
+* @korean 자세방어상태들
+*/
+var STANCE_GUARD_STATES = [
+	AnimationState.STANCE_GUARD_GEON,
+	AnimationState.STANCE_GUARD_TAE,
+	AnimationState.STANCE_GUARD_LI,
+	AnimationState.STANCE_GUARD_JIN,
+	AnimationState.STANCE_GUARD_SON,
+	AnimationState.STANCE_GUARD_GAM,
+	AnimationState.STANCE_GUARD_GAN,
+	AnimationState.STANCE_GUARD_GON
+];
+/**
+* Order of trigram stances in the stance wheel (circular arrangement)
+*
+* **Korean**: 팔괘 순서
+*
+* The 8 trigrams arranged in traditional order around the Bagua octagon.
+* Adjacent stances in this array are considered "adjacent" for transition purposes.
+*
+* @korean 팔괘순서
+*/
+var TRIGRAM_STANCES_ORDER = [
+	TrigramStance.GEON,
+	TrigramStance.TAE,
+	TrigramStance.LI,
+	TrigramStance.JIN,
+	TrigramStance.SON,
+	TrigramStance.GAM,
+	TrigramStance.GAN,
+	TrigramStance.GON
+];
+/**
+* Fall animation states (낙법 상태)
+* @korean 낙법상태들
+*/
+var FALL_STATES = [
+	AnimationState.FALL_FORWARD,
+	AnimationState.FALL_BACKWARD,
+	AnimationState.FALL_SIDE_LEFT,
+	AnimationState.FALL_SIDE_RIGHT
+];
+/**
+* Ground position states (지면 자세)
+* @korean 지면자세들
+*/
+var GROUND_STATES = [
+	AnimationState.GROUND_PRONE,
+	AnimationState.GROUND_SUPINE,
+	AnimationState.GROUND_SIDE_LEFT,
+	AnimationState.GROUND_SIDE_RIGHT
+];
+/**
+* Recovery animation states (기상 애니메이션)
+* @korean 회복애니메이션들
+*/
+var RECOVERY_STATES = [
+	AnimationState.RECOVERY_PRONE_STANDUP,
+	AnimationState.RECOVERY_SUPINE_STANDUP,
+	AnimationState.RECOVERY_ROLL,
+	AnimationState.RECOVERY_DEFENSIVE
+];
+/**
+* Generate transition rules for fall animations
+*
+* Fall animations have highest priority and can interrupt any state.
+* Falls automatically transition to ground states upon completion.
+* Ground states can transition to recovery animations.
+* Recovery animations transition to idle upon completion.
+*
+* @korean 낙법전환규칙생성
+*/
+function generateFallTransitions() {
+	const transitions = [];
+	const nonFallStates = [
+		AnimationState.IDLE,
+		AnimationState.WALK,
+		AnimationState.RUN,
+		AnimationState.ATTACK,
+		AnimationState.DEFEND,
+		AnimationState.HIT,
+		AnimationState.STANCE_CHANGE,
+		AnimationState.STANCE_SIDE_SWITCH,
+		...STANCE_GUARD_STATES
+	];
+	for (const fromState of nonFallStates) for (const fallState of FALL_STATES) transitions.push({
+		from: fromState,
+		to: fallState,
+		allowed: true
+	});
+	for (const fallState of FALL_STATES) {
+		const fallType = fallState.replace("fall_", "");
+		if (fallType === "forward" || fallType === "backward" || fallType === "side_left" || fallType === "side_right") {
+			const groundAnimState = `ground_${FALL_TO_GROUND_MAP[fallType]}`;
+			transitions.push({
+				from: fallState,
+				to: groundAnimState,
+				allowed: true
+			});
+		}
+	}
+	for (const groundState of GROUND_STATES) {
+		for (const recoveryState of RECOVERY_STATES) transitions.push({
+			from: groundState,
+			to: recoveryState,
+			allowed: true
+		});
+		transitions.push({
+			from: groundState,
+			to: AnimationState.HIT,
+			allowed: true
+		}, {
+			from: groundState,
+			to: AnimationState.KO,
+			allowed: true
+		});
+		for (const fallState of FALL_STATES) transitions.push({
+			from: groundState,
+			to: fallState,
+			allowed: true
+		});
+	}
+	for (const recoveryState of RECOVERY_STATES) {
+		for (const fallState of FALL_STATES) transitions.push({
+			from: recoveryState,
+			to: fallState,
+			allowed: true
+		});
+		transitions.push({
+			from: recoveryState,
+			to: AnimationState.HIT,
+			allowed: true
+		}, {
+			from: recoveryState,
+			to: AnimationState.KO,
+			allowed: true
+		});
+		transitions.push({
+			from: recoveryState,
+			to: AnimationState.IDLE,
+			allowed: true
+		});
+	}
+	return transitions;
+}
+/**
+* Generate transition rules for stance guards
+*
+* Each stance guard can transition to:
+* - walk, run (movement)
+* - attack, defend (combat actions)
+* - step_{direction} (tactical steps while maintaining guard)
+* - stance_change (changing stance)
+* - hit, ko (being hit)
+* - other stance guards (direct stance change with guard)
+*
+* @korean 자세방어전환규칙생성
+*/
+function generateStanceGuardTransitions() {
+	const transitions = [];
+	const stepDirections = [
+		AnimationState.STEP_FORWARD,
+		AnimationState.STEP_BACK,
+		AnimationState.STEP_LEFT,
+		AnimationState.STEP_RIGHT,
+		AnimationState.STEP_FORWARD_LEFT,
+		AnimationState.STEP_FORWARD_RIGHT,
+		AnimationState.STEP_BACK_LEFT,
+		AnimationState.STEP_BACK_RIGHT
+	];
+	for (const guardState of STANCE_GUARD_STATES) {
+		transitions.push({
+			from: guardState,
+			to: AnimationState.IDLE,
+			allowed: true
+		}, {
+			from: guardState,
+			to: AnimationState.WALK,
+			allowed: true
+		}, {
+			from: guardState,
+			to: AnimationState.RUN,
+			allowed: true
+		});
+		transitions.push({
+			from: guardState,
+			to: AnimationState.ATTACK,
+			allowed: true
+		}, {
+			from: guardState,
+			to: AnimationState.DEFEND,
+			allowed: true
+		}, {
+			from: guardState,
+			to: AnimationState.STANCE_CHANGE,
+			allowed: true
+		});
+		for (const stepDirection of stepDirections) transitions.push({
+			from: guardState,
+			to: stepDirection,
+			allowed: true
+		});
+		transitions.push({
+			from: guardState,
+			to: AnimationState.HIT,
+			allowed: true
+		}, {
+			from: guardState,
+			to: AnimationState.KO,
+			allowed: true
+		});
+		for (const otherGuard of STANCE_GUARD_STATES) if (guardState !== otherGuard) transitions.push({
+			from: guardState,
+			to: otherGuard,
+			allowed: true
+		});
+		transitions.push({
+			from: AnimationState.IDLE,
+			to: guardState,
+			allowed: true
+		}, {
+			from: AnimationState.WALK,
+			to: guardState,
+			allowed: true
+		}, {
+			from: AnimationState.RUN,
+			to: guardState,
+			allowed: true
+		}, {
+			from: AnimationState.DEFEND,
+			to: guardState,
+			allowed: true
+		});
+		for (const stepDirection of stepDirections) transitions.push({
+			from: stepDirection,
+			to: guardState,
+			allowed: true
+		});
+	}
+	return transitions;
+}
+/**
+* Default transition rules for animation states
+*
+* @korean 기본전환규칙
+*/
+var DEFAULT_TRANSITIONS = [
+	{
+		from: AnimationState.IDLE,
+		to: AnimationState.WALK,
+		allowed: true
+	},
+	{
+		from: AnimationState.IDLE,
+		to: AnimationState.RUN,
+		allowed: true
+	},
+	{
+		from: AnimationState.IDLE,
+		to: AnimationState.ATTACK,
+		allowed: true
+	},
+	{
+		from: AnimationState.IDLE,
+		to: AnimationState.DEFEND,
+		allowed: true
+	},
+	{
+		from: AnimationState.IDLE,
+		to: AnimationState.STANCE_CHANGE,
+		allowed: true
+	},
+	{
+		from: AnimationState.IDLE,
+		to: AnimationState.HIT,
+		allowed: true
+	},
+	{
+		from: AnimationState.IDLE,
+		to: AnimationState.KO,
+		allowed: true
+	},
+	{
+		from: AnimationState.WALK,
+		to: AnimationState.IDLE,
+		allowed: true
+	},
+	{
+		from: AnimationState.WALK,
+		to: AnimationState.RUN,
+		allowed: true
+	},
+	{
+		from: AnimationState.WALK,
+		to: AnimationState.ATTACK,
+		allowed: true
+	},
+	{
+		from: AnimationState.WALK,
+		to: AnimationState.DEFEND,
+		allowed: true
+	},
+	{
+		from: AnimationState.WALK,
+		to: AnimationState.STANCE_CHANGE,
+		allowed: true
+	},
+	{
+		from: AnimationState.WALK,
+		to: AnimationState.HIT,
+		allowed: true
+	},
+	{
+		from: AnimationState.WALK,
+		to: AnimationState.KO,
+		allowed: true
+	},
+	{
+		from: AnimationState.RUN,
+		to: AnimationState.IDLE,
+		allowed: true
+	},
+	{
+		from: AnimationState.RUN,
+		to: AnimationState.WALK,
+		allowed: true
+	},
+	{
+		from: AnimationState.RUN,
+		to: AnimationState.ATTACK,
+		allowed: true
+	},
+	{
+		from: AnimationState.RUN,
+		to: AnimationState.DEFEND,
+		allowed: true
+	},
+	{
+		from: AnimationState.RUN,
+		to: AnimationState.STANCE_CHANGE,
+		allowed: true
+	},
+	{
+		from: AnimationState.RUN,
+		to: AnimationState.HIT,
+		allowed: true
+	},
+	{
+		from: AnimationState.RUN,
+		to: AnimationState.KO,
+		allowed: true
+	},
+	{
+		from: AnimationState.ATTACK,
+		to: AnimationState.IDLE,
+		allowed: true
+	},
+	{
+		from: AnimationState.ATTACK,
+		to: AnimationState.HIT,
+		allowed: true
+	},
+	{
+		from: AnimationState.ATTACK,
+		to: AnimationState.KO,
+		allowed: true
+	},
+	{
+		from: AnimationState.DEFEND,
+		to: AnimationState.IDLE,
+		allowed: true
+	},
+	{
+		from: AnimationState.DEFEND,
+		to: AnimationState.WALK,
+		allowed: true
+	},
+	{
+		from: AnimationState.DEFEND,
+		to: AnimationState.HIT,
+		allowed: true
+	},
+	{
+		from: AnimationState.DEFEND,
+		to: AnimationState.KO,
+		allowed: true
+	},
+	{
+		from: AnimationState.HIT,
+		to: AnimationState.IDLE,
+		allowed: true
+	},
+	{
+		from: AnimationState.HIT,
+		to: AnimationState.HIT,
+		allowed: true
+	},
+	{
+		from: AnimationState.HIT,
+		to: AnimationState.KO,
+		allowed: true
+	},
+	{
+		from: AnimationState.STANCE_CHANGE,
+		to: AnimationState.IDLE,
+		allowed: true
+	},
+	{
+		from: AnimationState.STANCE_CHANGE,
+		to: AnimationState.HIT,
+		allowed: true
+	},
+	{
+		from: AnimationState.STANCE_CHANGE,
+		to: AnimationState.KO,
+		allowed: true
+	},
+	{
+		from: AnimationState.IDLE,
+		to: AnimationState.STEP_FORWARD,
+		allowed: true
+	},
+	{
+		from: AnimationState.WALK,
+		to: AnimationState.STEP_FORWARD,
+		allowed: true
+	},
+	{
+		from: AnimationState.STEP_FORWARD,
+		to: AnimationState.IDLE,
+		allowed: true
+	},
+	{
+		from: AnimationState.STEP_FORWARD,
+		to: AnimationState.HIT,
+		allowed: true
+	},
+	{
+		from: AnimationState.STEP_FORWARD,
+		to: AnimationState.KO,
+		allowed: true
+	},
+	{
+		from: AnimationState.IDLE,
+		to: AnimationState.STEP_BACK,
+		allowed: true
+	},
+	{
+		from: AnimationState.WALK,
+		to: AnimationState.STEP_BACK,
+		allowed: true
+	},
+	{
+		from: AnimationState.STEP_BACK,
+		to: AnimationState.IDLE,
+		allowed: true
+	},
+	{
+		from: AnimationState.STEP_BACK,
+		to: AnimationState.HIT,
+		allowed: true
+	},
+	{
+		from: AnimationState.STEP_BACK,
+		to: AnimationState.KO,
+		allowed: true
+	},
+	{
+		from: AnimationState.IDLE,
+		to: AnimationState.STEP_LEFT,
+		allowed: true
+	},
+	{
+		from: AnimationState.WALK,
+		to: AnimationState.STEP_LEFT,
+		allowed: true
+	},
+	{
+		from: AnimationState.STEP_LEFT,
+		to: AnimationState.IDLE,
+		allowed: true
+	},
+	{
+		from: AnimationState.STEP_LEFT,
+		to: AnimationState.HIT,
+		allowed: true
+	},
+	{
+		from: AnimationState.STEP_LEFT,
+		to: AnimationState.KO,
+		allowed: true
+	},
+	{
+		from: AnimationState.IDLE,
+		to: AnimationState.STEP_RIGHT,
+		allowed: true
+	},
+	{
+		from: AnimationState.WALK,
+		to: AnimationState.STEP_RIGHT,
+		allowed: true
+	},
+	{
+		from: AnimationState.STEP_RIGHT,
+		to: AnimationState.IDLE,
+		allowed: true
+	},
+	{
+		from: AnimationState.STEP_RIGHT,
+		to: AnimationState.HIT,
+		allowed: true
+	},
+	{
+		from: AnimationState.STEP_RIGHT,
+		to: AnimationState.KO,
+		allowed: true
+	},
+	{
+		from: AnimationState.IDLE,
+		to: AnimationState.STEP_FORWARD_LEFT,
+		allowed: true
+	},
+	{
+		from: AnimationState.WALK,
+		to: AnimationState.STEP_FORWARD_LEFT,
+		allowed: true
+	},
+	{
+		from: AnimationState.STEP_FORWARD_LEFT,
+		to: AnimationState.IDLE,
+		allowed: true
+	},
+	{
+		from: AnimationState.STEP_FORWARD_LEFT,
+		to: AnimationState.HIT,
+		allowed: true
+	},
+	{
+		from: AnimationState.STEP_FORWARD_LEFT,
+		to: AnimationState.KO,
+		allowed: true
+	},
+	{
+		from: AnimationState.IDLE,
+		to: AnimationState.STEP_FORWARD_RIGHT,
+		allowed: true
+	},
+	{
+		from: AnimationState.WALK,
+		to: AnimationState.STEP_FORWARD_RIGHT,
+		allowed: true
+	},
+	{
+		from: AnimationState.STEP_FORWARD_RIGHT,
+		to: AnimationState.IDLE,
+		allowed: true
+	},
+	{
+		from: AnimationState.STEP_FORWARD_RIGHT,
+		to: AnimationState.HIT,
+		allowed: true
+	},
+	{
+		from: AnimationState.STEP_FORWARD_RIGHT,
+		to: AnimationState.KO,
+		allowed: true
+	},
+	{
+		from: AnimationState.IDLE,
+		to: AnimationState.STEP_BACK_LEFT,
+		allowed: true
+	},
+	{
+		from: AnimationState.WALK,
+		to: AnimationState.STEP_BACK_LEFT,
+		allowed: true
+	},
+	{
+		from: AnimationState.STEP_BACK_LEFT,
+		to: AnimationState.IDLE,
+		allowed: true
+	},
+	{
+		from: AnimationState.STEP_BACK_LEFT,
+		to: AnimationState.HIT,
+		allowed: true
+	},
+	{
+		from: AnimationState.STEP_BACK_LEFT,
+		to: AnimationState.KO,
+		allowed: true
+	},
+	{
+		from: AnimationState.IDLE,
+		to: AnimationState.STEP_BACK_RIGHT,
+		allowed: true
+	},
+	{
+		from: AnimationState.WALK,
+		to: AnimationState.STEP_BACK_RIGHT,
+		allowed: true
+	},
+	{
+		from: AnimationState.STEP_BACK_RIGHT,
+		to: AnimationState.IDLE,
+		allowed: true
+	},
+	{
+		from: AnimationState.STEP_BACK_RIGHT,
+		to: AnimationState.HIT,
+		allowed: true
+	},
+	{
+		from: AnimationState.STEP_BACK_RIGHT,
+		to: AnimationState.KO,
+		allowed: true
+	},
+	...generateFallTransitions(),
+	...generateStanceGuardTransitions()
+];
+/**
+* Check if a transition from one animation state to another is allowed
+*
+* @param from - Source animation state
+* @param to - Target animation state
+* @param transitions - Optional custom transition rules (defaults to DEFAULT_TRANSITIONS)
+* @returns Whether the transition is allowed
+*
+* @example
+* ```typescript
+* // Valid transitions
+* isTransitionAllowed("idle", "walk"); // true
+* isTransitionAllowed("attack", "idle"); // true
+* isTransitionAllowed("hit", "idle"); // true
+*
+* // Invalid transitions
+* isTransitionAllowed("ko", "idle"); // false (KO is terminal)
+* isTransitionAllowed("attack", "walk"); // false (must return to idle first)
+* ```
+*
+* @korean 전환허용여부확인
+*/
+function isTransitionAllowed(from, to, transitions = DEFAULT_TRANSITIONS) {
+	if (from === to) return true;
+	const rule = transitions.find((t) => t.from === from && t.to === to);
+	if (!rule) return false;
+	if (rule.condition) return rule.condition();
+	return rule.allowed;
+}
+/**
+* Calculate stance adjacency (distance around the stance wheel)
+*
+* **Korean**: 자세 인접도 계산
+*
+* Determines how many steps apart two stances are on the octagonal stance wheel.
+* Returns 0 for same stance, 1-3 for adjacent stances, 4 for opposite stances.
+*
+* @param from - Source stance
+* @param to - Target stance
+* @returns Number of steps apart (0-4)
+*
+* @example
+* ```typescript
+* calculateStanceDistance(TrigramStance.GEON, TrigramStance.TAE); // 1 (adjacent)
+* calculateStanceDistance(TrigramStance.GEON, TrigramStance.SON); // 4 (opposite)
+* calculateStanceDistance(TrigramStance.GEON, TrigramStance.GEON); // 0 (same)
+* ```
+*
+* @korean 자세거리계산
+*/
+function calculateStanceDistance(from, to) {
+	if (from === to) return 0;
+	const fromIndex = TRIGRAM_STANCES_ORDER.indexOf(from);
+	const toIndex = TRIGRAM_STANCES_ORDER.indexOf(to);
+	if (fromIndex === -1 || toIndex === -1) {
+		console.warn(`Invalid stance in distance calculation: ${from} -> ${to}`);
+		return 4;
+	}
+	const directDistance = Math.abs(toIndex - fromIndex);
+	const wrapDistance = TRIGRAM_STANCES_ORDER.length - directDistance;
+	return Math.min(directDistance, wrapDistance);
+}
+/**
+* Determine transition type based on stance distance
+*
+* **Korean**: 전환 유형 결정
+*
+* Classifies transition as direct (adjacent), indirect (opposite), or self.
+*
+* @param from - Source stance
+* @param to - Target stance
+* @returns Transition type
+*
+* @korean 전환유형결정
+*/
+function determineTransitionType(from, to) {
+	const distance = calculateStanceDistance(from, to);
+	if (distance === 0) return "self";
+	if (distance <= 2) return "direct";
+	return "indirect";
+}
+/**
+* Generate keyframes for direct stance transition (adjacent stances)
+*
+* **Korean**: 직접 전환 키프레임 생성
+*
+* Creates smooth keyframes for transitions between adjacent stances.
+* Phase breakdown:
+* - Frames 0-12: Weight shift away from source stance
+* - Frames 12-24: Foot repositioning
+* - Frames 24-36: Guard change to target stance
+*
+* @param from - Source stance
+* @param to - Target stance
+* @returns Array of keyframes
+*
+* @korean 직접전환키프레임생성
+*/
+function generateDirectTransitionKeyframes(from, to) {
+	return [
+		{
+			frame: 0,
+			stance: from,
+			blend: 1
+		},
+		{
+			frame: 6,
+			stance: from,
+			blend: .8
+		},
+		{
+			frame: 12,
+			stance: "neutral",
+			blend: .5
+		},
+		{
+			frame: 18,
+			stance: "neutral",
+			blend: .4
+		},
+		{
+			frame: 24,
+			stance: to,
+			blend: .3
+		},
+		{
+			frame: 30,
+			stance: to,
+			blend: .7
+		},
+		{
+			frame: 36,
+			stance: to,
+			blend: 1
+		}
+	];
+}
+/**
+* Generate keyframes for indirect stance transition (opposite stances)
+*
+* **Korean**: 간접 전환 키프레임 생성
+*
+* Creates keyframes for transitions between opposite stances via neutral position.
+* Longer neutral phase for more complex repositioning.
+*
+* @param from - Source stance
+* @param to - Target stance
+* @returns Array of keyframes
+*
+* @korean 간접전환키프레임생성
+*/
+function generateIndirectTransitionKeyframes(from, to) {
+	return [
+		{
+			frame: 0,
+			stance: from,
+			blend: 1
+		},
+		{
+			frame: 6,
+			stance: from,
+			blend: .7
+		},
+		{
+			frame: 12,
+			stance: "neutral",
+			blend: .5
+		},
+		{
+			frame: 18,
+			stance: "neutral",
+			blend: .5
+		},
+		{
+			frame: 24,
+			stance: "neutral",
+			blend: .4
+		},
+		{
+			frame: 30,
+			stance: to,
+			blend: .6
+		},
+		{
+			frame: 36,
+			stance: to,
+			blend: 1
+		}
+	];
+}
+/**
+* Create a stance transition configuration
+*
+* **Korean**: 자세 전환 생성
+*
+* Generates complete transition configuration between two stances.
+*
+* @param from - Source stance
+* @param to - Target stance
+* @returns Complete stance transition configuration
+*
+* @korean 자세전환생성
+*/
+function createStanceTransition(from, to) {
+	const type = determineTransitionType(from, to);
+	if (type === "self") return {
+		from,
+		to,
+		type: "self",
+		duration: 0,
+		keyframes: [{
+			frame: 0,
+			stance: from,
+			blend: 1
+		}],
+		description: {
+			korean: `${from} 자세 유지`,
+			english: `Maintain ${from} stance`
+		}
+	};
+	return {
+		from,
+		to,
+		type,
+		duration: 600,
+		keyframes: type === "direct" ? generateDirectTransitionKeyframes(from, to) : generateIndirectTransitionKeyframes(from, to),
+		description: {
+			korean: `${from}에서 ${to}로 전환`,
+			english: `Transition from ${from} to ${to}`
+		}
+	};
+}
+/**
+* Stance transition matrix containing all 64 transitions (8x8)
+*
+* **Korean**: 팔괘 전환 행렬
+*
+* Maps from every stance to every other stance, including self-transitions.
+* Key format: "from_to" (e.g., "geon_tae")
+*
+* Total transitions: 64 (8 source stances × 8 target stances)
+* - 8 self-transitions (0ms)
+* - ~24 direct transitions (600ms, adjacent stances)
+* - ~32 indirect transitions (600ms, opposite stances)
+*
+* @korean 팔괘전환행렬
+*/
+var STANCE_TRANSITIONS = /* @__PURE__ */ new Map();
+/**
+* Initialize the stance transition matrix
+*
+* **Korean**: 전환 행렬 초기화
+*
+* Generates all 64 stance transitions and populates the transition map.
+* Call this during system initialization.
+*
+* @korean 전환행렬초기화
+*/
+function initializeStanceTransitions() {
+	for (const from of TRIGRAM_STANCES_ORDER) for (const to of TRIGRAM_STANCES_ORDER) {
+		const key = `${from}_${to}`;
+		const transition = createStanceTransition(from, to);
+		STANCE_TRANSITIONS.set(key, transition);
+	}
+	if (process.env.NODE_ENV === "development") console.log(`[StanceTransitions] Initialized ${STANCE_TRANSITIONS.size} stance transitions`);
+}
+/**
+* Get stance transition configuration
+*
+* **Korean**: 자세 전환 가져오기
+*
+* Retrieves the transition configuration for moving from one stance to another.
+*
+* @param from - Source stance
+* @param to - Target stance
+* @returns Transition configuration, or undefined if not found
+*
+* @example
+* ```typescript
+* const transition = getStanceTransition(TrigramStance.GEON, TrigramStance.TAE);
+* console.log(transition.duration); // 600
+* console.log(transition.type); // "direct"
+* ```
+*
+* @korean 자세전환가져오기
+*/
+function getStanceTransition(from, to) {
+	const key = `${from}_${to}`;
+	return STANCE_TRANSITIONS.get(key);
+}
+initializeStanceTransitions();
+//#endregion
+export { DEFAULT_TRANSITIONS, TRIGRAM_STANCES_ORDER, calculateStanceDistance, determineTransitionType, getStanceTransition, isTransitionAllowed };
+
+//# sourceMappingURL=AnimationTransitions.js.map