blacktrigram 0.7.2

package/lib/systems/trigram/StanceManager.js

@@ -0,0 +1,192 @@
+import { TrigramStance } from "../../types/common.js";
+import { PLAYER_ARCHETYPES_DATA } from "../types.js";
+import { TrigramCalculator } from "./TrigramCalculator.js";
+//#region src/systems/trigram/StanceManager.ts
+/**
+* Manager for trigram stance changes and laterality state
+* 
+* **Korean**: 자세 관리자
+* 
+* Manages both trigram stance selection (8 stances) and laterality (left/right).
+* Supports authentic Korean martial arts stance configurations with:
+* - 8 trigram stances (☰–☷)
+* - 2 laterality options (left/right foot forward)
+* - 16 total stance configurations
+* 
+* Laterality transitions take 400ms (24 frames @ 60fps) and cost 2 stamina.
+*/
+var StanceManager = class {
+	minTransitionInterval = 500;
+	lateralityTransitionTime = 400;
+	currentStance;
+	currentLaterality = "right";
+	constructor() {}
+	/**
+	* Get the current stance
+	* 
+	* @returns Current trigram stance or undefined if not set
+	* @korean 현재자세가져오기
+	*/
+	getCurrent() {
+		return this.currentStance;
+	}
+	/**
+	* Get the current stance laterality (left or right foot forward)
+	* 
+	* **Korean**: 현재 측면성
+	* 
+	* @returns Current laterality ("left" or "right")
+	* @korean 현재측면성가져오기
+	*/
+	getCurrentLaterality() {
+		return this.currentLaterality;
+	}
+	/**
+	* Switch stance side (left ↔ right) without changing trigram stance
+	* 
+	* **Korean**: 자세 측면 전환
+	* 
+	* Mirrors the current guard position from left to right or vice versa.
+	* Takes 400ms (24 frames @ 60fps) and costs 2 stamina.
+	* 
+	* Korean terminology:
+	* - 왼발서기 (Oenbal Seogi): Left foot forward
+	* - 오른발서기 (Oreun Bal Seogi): Right foot forward
+	* 
+	* @param player - Current player state
+	* @param currentLaterality - Current laterality to toggle from
+	* @returns Result with updated laterality
+	* @korean 측면전환
+	*/
+	switchStanceSide(player, currentLaterality) {
+		const lateralityCost = {
+			ki: 0,
+			stamina: 2,
+			timeMilliseconds: this.lateralityTransitionTime
+		};
+		if (player.stamina < lateralityCost.stamina) return {
+			success: false,
+			updatedPlayer: player,
+			cost: lateralityCost,
+			laterality: currentLaterality,
+			message: "Insufficient stamina to switch stance side"
+		};
+		if (Date.now() - (player.lastStanceChangeTime || 0) < this.minTransitionInterval) return {
+			success: false,
+			updatedPlayer: player,
+			cost: lateralityCost,
+			laterality: currentLaterality,
+			message: "Stance side switch on cooldown"
+		};
+		const newLaterality = currentLaterality === "left" ? "right" : "left";
+		this.currentLaterality = newLaterality;
+		return {
+			success: true,
+			updatedPlayer: {
+				...player,
+				stamina: Math.max(0, player.stamina - lateralityCost.stamina),
+				lastStanceChangeTime: Date.now()
+			},
+			cost: lateralityCost,
+			laterality: newLaterality
+		};
+	}
+	/**
+	* Attempt to change stance
+	* 
+	* @param player - Current player state
+	* @param newStance - Target trigram stance
+	* @returns Result with success status and updated player
+	* @korean 자세변경
+	*/
+	changeStance(player, newStance) {
+		const cost = this.getStanceTransitionCost(player.currentStance, newStance, player);
+		if (!this.canChangeStance(player, newStance)) return {
+			success: false,
+			updatedPlayer: player,
+			cost,
+			laterality: this.currentLaterality,
+			message: "Cannot change stance - insufficient resources or cooldown active"
+		};
+		if (player.currentStance === newStance) {
+			this.currentStance = newStance;
+			return {
+				success: true,
+				updatedPlayer: {
+					...player,
+					lastStanceChangeTime: Date.now()
+				},
+				cost: {
+					ki: 0,
+					stamina: 0,
+					timeMilliseconds: 0
+				},
+				laterality: this.currentLaterality
+			};
+		}
+		const updatedPlayer = {
+			...player,
+			currentStance: newStance,
+			ki: Math.max(0, player.ki - cost.ki),
+			stamina: Math.max(0, player.stamina - cost.stamina),
+			lastStanceChangeTime: Date.now()
+		};
+		this.currentStance = newStance;
+		return {
+			success: true,
+			updatedPlayer,
+			cost,
+			laterality: this.currentLaterality
+		};
+	}
+	/**
+	* Check if player can change to the specified stance
+	*/
+	canChangeStance(player, newStance) {
+		const cost = this.getStanceTransitionCost(player.currentStance, newStance, player);
+		if (player.ki < cost.ki || player.stamina < cost.stamina) return false;
+		if (Date.now() - (player.lastStanceChangeTime || 0) < this.minTransitionInterval) return false;
+		if (player.isStunned || player.consciousness < 50) return false;
+		return true;
+	}
+	/**
+	* Calculate the cost of transitioning between stances
+	*/
+	getStanceTransitionCost(fromStance, toStance, player) {
+		if (fromStance === toStance) return {
+			ki: 0,
+			stamina: 0,
+			timeMilliseconds: 0
+		};
+		const baseCost = {
+			ki: 10,
+			stamina: 15,
+			timeMilliseconds: 500
+		};
+		const difficultyMultiplier = 1 + TrigramCalculator.calculateTransitionDifficulty(fromStance, toStance);
+		const archetypeModifier = (PLAYER_ARCHETYPES_DATA[player.archetype].favoredStances || []).includes(toStance) ? .8 : 1;
+		return {
+			ki: Math.floor(baseCost.ki * difficultyMultiplier * archetypeModifier),
+			stamina: Math.floor(baseCost.stamina * difficultyMultiplier * archetypeModifier),
+			timeMilliseconds: Math.floor(baseCost.timeMilliseconds * difficultyMultiplier)
+		};
+	}
+	/**
+	* Get optimal stance recommendation
+	*/
+	getOptimalStance(player, opponent) {
+		if (opponent) return TrigramCalculator.getCounterStance(opponent.currentStance);
+		const favoredStances = PLAYER_ARCHETYPES_DATA[player.archetype].favoredStances || [];
+		return favoredStances.length > 0 ? favoredStances[0] : TrigramStance.GEON;
+	}
+	/**
+	* Get all valid transitions from current stance
+	*/
+	getValidTransitions(player) {
+		return Object.values(TrigramStance).filter((stance) => this.canChangeStance(player, stance));
+	}
+};
+//#endregion
+export { StanceManager };
+
+//# sourceMappingURL=StanceManager.js.map

package/lib/systems/trigram/StanceManager.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"StanceManager.js","names":[],"sources":["../../../src/systems/trigram/StanceManager.ts"],"sourcesContent":["import { TrigramStance } from \"../../types/common\";\nimport { PlayerState } from \"../player\";\nimport { PLAYER_ARCHETYPES_DATA } from \"../types\";\nimport { TrigramCalculator } from \"./TrigramCalculator\";\nimport { StanceLaterality, TrigramTransitionCost } from \"./types\";\n\nexport interface StanceChangeResult {\n  readonly success: boolean;\n  readonly updatedPlayer: PlayerState;\n  readonly cost: TrigramTransitionCost;\n  readonly laterality?: StanceLaterality;\n  readonly message?: string;\n}\n\n/**\n * Manager for trigram stance changes and laterality state\n * \n * **Korean**: 자세 관리자\n * \n * Manages both trigram stance selection (8 stances) and laterality (left/right).\n * Supports authentic Korean martial arts stance configurations with:\n * - 8 trigram stances (☰–☷)\n * - 2 laterality options (left/right foot forward)\n * - 16 total stance configurations\n * \n * Laterality transitions take 400ms (24 frames @ 60fps) and cost 2 stamina.\n */\nexport class StanceManager {\n  private readonly minTransitionInterval = 500;\n  private readonly lateralityTransitionTime = 400; // 400ms for stance side switch\n  private currentStance?: TrigramStance;\n  private currentLaterality: StanceLaterality = \"right\"; // Default: right foot forward\n\n  constructor() {\n    // No initialization needed\n  }\n\n  /**\n   * Get the current stance\n   * \n   * @returns Current trigram stance or undefined if not set\n   * @korean 현재자세가져오기\n   */\n  public getCurrent(): TrigramStance | undefined {\n    return this.currentStance;\n  }\n\n  /**\n   * Get the current stance laterality (left or right foot forward)\n   * \n   * **Korean**: 현재 측면성\n   * \n   * @returns Current laterality (\"left\" or \"right\")\n   * @korean 현재측면성가져오기\n   */\n  public getCurrentLaterality(): StanceLaterality {\n    return this.currentLaterality;\n  }\n\n  /**\n   * Switch stance side (left ↔ right) without changing trigram stance\n   * \n   * **Korean**: 자세 측면 전환\n   * \n   * Mirrors the current guard position from left to right or vice versa.\n   * Takes 400ms (24 frames @ 60fps) and costs 2 stamina.\n   * \n   * Korean terminology:\n   * - 왼발서기 (Oenbal Seogi): Left foot forward\n   * - 오른발서기 (Oreun Bal Seogi): Right foot forward\n   * \n   * @param player - Current player state\n   * @param currentLaterality - Current laterality to toggle from\n   * @returns Result with updated laterality\n   * @korean 측면전환\n   */\n  public switchStanceSide(player: PlayerState, currentLaterality: StanceLaterality): StanceChangeResult {\n    const lateralityCost: TrigramTransitionCost = {\n      ki: 0,\n      stamina: 2,\n      timeMilliseconds: this.lateralityTransitionTime,\n    };\n\n    // Check if player has enough stamina\n    if (player.stamina < lateralityCost.stamina) {\n      return {\n        success: false,\n        updatedPlayer: player,\n        cost: lateralityCost,\n        laterality: currentLaterality,\n        message: \"Insufficient stamina to switch stance side\",\n      };\n    }\n\n    // Check cooldown\n    const timeSinceLastChange = Date.now() - (player.lastStanceChangeTime || 0);\n    if (timeSinceLastChange < this.minTransitionInterval) {\n      return {\n        success: false,\n        updatedPlayer: player,\n        cost: lateralityCost,\n        laterality: currentLaterality,\n        message: \"Stance side switch on cooldown\",\n      };\n    }\n\n    // Switch laterality (toggle from current)\n    const newLaterality: StanceLaterality = \n      currentLaterality === \"left\" ? \"right\" : \"left\";\n    this.currentLaterality = newLaterality;\n\n    // Apply stamina cost and update timestamp\n    const updatedPlayer: PlayerState = {\n      ...player,\n      stamina: Math.max(0, player.stamina - lateralityCost.stamina),\n      lastStanceChangeTime: Date.now(),\n    };\n\n    return {\n      success: true,\n      updatedPlayer,\n      cost: lateralityCost,\n      laterality: newLaterality,\n    };\n  }\n\n  /**\n   * Attempt to change stance\n   * \n   * @param player - Current player state\n   * @param newStance - Target trigram stance\n   * @returns Result with success status and updated player\n   * @korean 자세변경\n   */\n  changeStance(\n    player: PlayerState,\n    newStance: TrigramStance\n  ): StanceChangeResult {\n    const cost = this.getStanceTransitionCost(\n      player.currentStance,\n      newStance,\n      player\n    );\n\n    // Check if transition is possible\n    if (!this.canChangeStance(player, newStance)) {\n      return {\n        success: false,\n        updatedPlayer: player,\n        cost,\n        laterality: this.currentLaterality,\n        message:\n          \"Cannot change stance - insufficient resources or cooldown active\",\n      };\n    }\n\n    // Same stance - no cost, but update laterality info\n    if (player.currentStance === newStance) {\n      this.currentStance = newStance;\n      return {\n        success: true,\n        updatedPlayer: {\n          ...player,\n          lastStanceChangeTime: Date.now(),\n        },\n        cost: { ki: 0, stamina: 0, timeMilliseconds: 0 },\n        laterality: this.currentLaterality,\n      };\n    }\n\n    // Apply stance change\n    const updatedPlayer: PlayerState = {\n      ...player,\n      currentStance: newStance,\n      ki: Math.max(0, player.ki - cost.ki),\n      stamina: Math.max(0, player.stamina - cost.stamina),\n      lastStanceChangeTime: Date.now(),\n    };\n    this.currentStance = newStance;\n\n    return {\n      success: true,\n      updatedPlayer,\n      cost,\n      laterality: this.currentLaterality,\n    };\n  }\n\n  /**\n   * Check if player can change to the specified stance\n   */\n  canChangeStance(player: PlayerState, newStance: TrigramStance): boolean {\n    const cost = this.getStanceTransitionCost(\n      player.currentStance,\n      newStance,\n      player\n    );\n\n    // Check resources\n    if (player.ki < cost.ki || player.stamina < cost.stamina) {\n      return false;\n    }\n\n    // Check cooldown\n    const timeSinceLastChange = Date.now() - (player.lastStanceChangeTime || 0);\n    if (timeSinceLastChange < this.minTransitionInterval) {\n      return false;\n    }\n\n    // Check if player is stunned or incapacitated\n    if (player.isStunned || player.consciousness < 50) {\n      return false;\n    }\n\n    return true;\n  }\n\n  /**\n   * Calculate the cost of transitioning between stances\n   */\n  getStanceTransitionCost(\n    fromStance: TrigramStance,\n    toStance: TrigramStance,\n    player: PlayerState\n  ): TrigramTransitionCost {\n    if (fromStance === toStance) {\n      return { ki: 0, stamina: 0, timeMilliseconds: 0 };\n    }\n\n    const baseCost = { ki: 10, stamina: 15, timeMilliseconds: 500 };\n    const difficulty = TrigramCalculator.calculateTransitionDifficulty(\n      fromStance,\n      toStance\n    );\n    const difficultyMultiplier = 1 + difficulty;\n\n    // Apply archetype modifiers\n    const archetypeData = PLAYER_ARCHETYPES_DATA[player.archetype];\n    const favoredStances = archetypeData.favoredStances || [];\n    const archetypeModifier = favoredStances.includes(toStance) ? 0.8 : 1.0;\n\n    return {\n      ki: Math.floor(baseCost.ki * difficultyMultiplier * archetypeModifier),\n      stamina: Math.floor(\n        baseCost.stamina * difficultyMultiplier * archetypeModifier\n      ),\n      timeMilliseconds: Math.floor(\n        baseCost.timeMilliseconds * difficultyMultiplier\n      ),\n    };\n  }\n\n  /**\n   * Get optimal stance recommendation\n   */\n  getOptimalStance(player: PlayerState, opponent?: PlayerState): TrigramStance {\n    if (opponent) {\n      // Get counter stance against opponent\n      return TrigramCalculator.getCounterStance(opponent.currentStance);\n    }\n\n    // Default to archetype preferred stance\n    const archetypeData = PLAYER_ARCHETYPES_DATA[player.archetype];\n    const favoredStances = archetypeData.favoredStances || [];\n\n    return favoredStances.length > 0 ? favoredStances[0] : TrigramStance.GEON; // Fix: Use enum value\n  }\n\n  /**\n   * Get all valid transitions from current stance\n   */\n  getValidTransitions(player: PlayerState): TrigramStance[] {\n    return Object.values(TrigramStance).filter(\n      (\n        stance // Fix: Use enum values\n      ) => this.canChangeStance(player, stance)\n    );\n  }\n}\n"],"mappings":"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"}

package/lib/systems/trigram/TransitionCalculator.d.ts

@@ -0,0 +1,132 @@
+import { TrigramStance } from "../../types";
+import { type StanceTransitionType } from "../animation/core/AnimationTransitions";
+import { PlayerState } from "../player";
+import { TrigramTransitionCost, TrigramTransitionRule } from "./types";
+/**
+ * Calculator for trigram stance transition costs and validation
+ *
+ * **Korean**: 자세 전환 계산기
+ *
+ * Calculates costs, paths, and validation for transitions between trigram stances.
+ * Integrates with the animation system's stance transition matrix.
+ *
+ * @category Trigram System
+ * @korean 자세전환계산기
+ */
+export declare class TransitionCalculator {
+    private calculateBaseCost;
+    generateTransitionRule(from: TrigramStance, to: TrigramStance): TrigramTransitionRule;
+    /**
+     * Calculate the cost of transitioning between stances
+     *
+     * **Korean**: 자세 전환 비용 계산
+     *
+     * Calculates ki, stamina, and time costs based on stance distance.
+     * Uses animation system's transition configurations for accurate timing.
+     *
+     * @param from - Source stance
+     * @param to - Target stance
+     * @returns Transition cost breakdown
+     *
+     * @korean 자세전환비용계산
+     */
+    static calculateCost(from: TrigramStance, to: TrigramStance): TrigramTransitionCost;
+    /**
+     * Check if a transition is valid for a player
+     */
+    static canTransition(from: TrigramStance, to: TrigramStance, player: PlayerState): boolean;
+    /**
+     * Check if transition is valid based on player state
+     */
+    static isTransitionValid(from: TrigramStance, to: TrigramStance, player: PlayerState): boolean;
+    /**
+     * Get Ki cost for transition
+     */
+    static getKiCost(from: TrigramStance, to: TrigramStance, _player: PlayerState): number;
+    /**
+     * Get Stamina cost for transition
+     */
+    static getStaminaCost(from: TrigramStance, to: TrigramStance, _player: PlayerState): number;
+    /**
+     * Get transition time
+     */
+    static getTransitionTime(from: TrigramStance, to: TrigramStance, _player: PlayerState): number;
+    /**
+     * Get adjacency modifier for stance transitions
+     *
+     * **Korean**: 인접도 수정자
+     *
+     * Uses the animation system's distance calculation for consistency.
+     * Adjacent stances (distance 1) get 0.7x cost, others get 1.0x cost.
+     *
+     * @param from - Source stance
+     * @param to - Target stance
+     * @returns Cost modifier (0.7 for adjacent, 1.0 for distant)
+     *
+     * @korean 인접도수정자
+     */
+    private static getAdjacencyModifier;
+    /**
+     * Get the shortest transition path between stances
+     *
+     * **Korean**: 최단 전환 경로
+     *
+     * For direct transitions, returns [from, to].
+     * For indirect transitions, may include intermediate stances for smoother animation.
+     *
+     * @param from - Source stance
+     * @param to - Target stance
+     * @returns Array of stances in transition path
+     *
+     * @example
+     * ```typescript
+     * // Adjacent stances - direct path
+     * getTransitionPath(TrigramStance.GEON, TrigramStance.TAE);
+     * // Returns: ["geon", "tae"]
+     *
+     * // Opposite stances - may use intermediate
+     * getTransitionPath(TrigramStance.GEON, TrigramStance.GON);
+     * // Returns: ["geon", "gon"] (direct is shortest even though opposite)
+     * ```
+     *
+     * @korean 최단전환경로
+     */
+    static getTransitionPath(from: TrigramStance, to: TrigramStance): TrigramStance[];
+    /**
+     * Get transition type for a stance change
+     *
+     * **Korean**: 전환 유형 가져오기
+     *
+     * Determines if transition is direct (adjacent), indirect (opposite), or self.
+     *
+     * @param from - Source stance
+     * @param to - Target stance
+     * @returns Transition type classification
+     *
+     * @korean 전환유형가져오기
+     */
+    static getTransitionType(from: TrigramStance, to: TrigramStance): StanceTransitionType;
+    /**
+     * Calculate stance distance around the wheel
+     *
+     * **Korean**: 자세 거리 계산
+     *
+     * Returns the number of steps between stances on the octagonal wheel.
+     *
+     * @param from - Source stance
+     * @param to - Target stance
+     * @returns Distance (0-4)
+     *
+     * @korean 자세거리계산
+     */
+    static getStanceDistance(from: TrigramStance, to: TrigramStance): number;
+    /**
+     * Calculate total cost for a transition path
+     */
+    static calculatePathCost(path: TrigramStance[]): TrigramTransitionCost;
+    /**
+     * Get all valid transitions from a stance
+     */
+    static getValidTransitions(from: TrigramStance, player: PlayerState): TrigramTransitionRule[];
+}
+//# sourceMappingURL=TransitionCalculator.d.ts.map

package/lib/systems/trigram/TransitionCalculator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TransitionCalculator.d.ts","sourceRoot":"","sources":["../../../src/systems/trigram/TransitionCalculator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAE5C,OAAO,EAIL,KAAK,oBAAoB,EAC1B,MAAM,wCAAwC,CAAC;AAChD,OAAO,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AACxC,OAAO,EAAE,qBAAqB,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAC;AAEvE;;;;;;;;;;GAUG;AACH,qBAAa,oBAAoB;IAC/B,OAAO,CAAC,iBAAiB;IAWzB,sBAAsB,CACpB,IAAI,EAAE,aAAa,EACnB,EAAE,EAAE,aAAa,GAChB,qBAAqB;IAgBxB;;;;;;;;;;;;;OAaG;IACH,MAAM,CAAC,aAAa,CAClB,IAAI,EAAE,aAAa,EACnB,EAAE,EAAE,aAAa,GAChB,qBAAqB;IAmBxB;;OAEG;IACH,MAAM,CAAC,aAAa,CAClB,IAAI,EAAE,aAAa,EACnB,EAAE,EAAE,aAAa,EACjB,MAAM,EAAE,WAAW,GAClB,OAAO;IAKV;;OAEG;IACH,MAAM,CAAC,iBAAiB,CACtB,IAAI,EAAE,aAAa,EACnB,EAAE,EAAE,aAAa,EACjB,MAAM,EAAE,WAAW,GAClB,OAAO;IAIV;;OAEG;IACH,MAAM,CAAC,SAAS,CACd,IAAI,EAAE,aAAa,EACnB,EAAE,EAAE,aAAa,EACjB,OAAO,EAAE,WAAW,GACnB,MAAM;IAIT;;OAEG;IACH,MAAM,CAAC,cAAc,CACnB,IAAI,EAAE,aAAa,EACnB,EAAE,EAAE,aAAa,EACjB,OAAO,EAAE,WAAW,GACnB,MAAM;IAIT;;OAEG;IACH,MAAM,CAAC,iBAAiB,CACtB,IAAI,EAAE,aAAa,EACnB,EAAE,EAAE,aAAa,EACjB,OAAO,EAAE,WAAW,GACnB,MAAM;IAIT;;;;;;;;;;;;;OAaG;IACH,OAAO,CAAC,MAAM,CAAC,oBAAoB;IAgBnC;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,MAAM,CAAC,iBAAiB,CACtB,IAAI,EAAE,aAAa,EACnB,EAAE,EAAE,aAAa,GAChB,aAAa,EAAE;IAQlB;;;;;;;;;;;;OAYG;IACH,MAAM,CAAC,iBAAiB,CACtB,IAAI,EAAE,aAAa,EACnB,EAAE,EAAE,aAAa,GAChB,oBAAoB;IAIvB;;;;;;;;;;;;OAYG;IACH,MAAM,CAAC,iBAAiB,CAAC,IAAI,EAAE,aAAa,EAAE,EAAE,EAAE,aAAa,GAAG,MAAM;IAIxE;;OAEG;IACH,MAAM,CAAC,iBAAiB,CAAC,IAAI,EAAE,aAAa,EAAE,GAAG,qBAAqB;IAiBtE;;OAEG;IACH,MAAM,CAAC,mBAAmB,CACxB,IAAI,EAAE,aAAa,EACnB,MAAM,EAAE,WAAW,GAClB,qBAAqB,EAAE;CAuB3B"}

package/lib/systems/trigram/TransitionCalculator.js

@@ -0,0 +1,233 @@
+import { TrigramStance } from "../../types/common.js";
+import { calculateStanceDistance, determineTransitionType, getStanceTransition } from "../animation/core/AnimationTransitions.js";
+//#region src/systems/trigram/TransitionCalculator.ts
+/**
+* Calculator for trigram stance transition costs and validation
+*
+* **Korean**: 자세 전환 계산기
+*
+* Calculates costs, paths, and validation for transitions between trigram stances.
+* Integrates with the animation system's stance transition matrix.
+*
+* @category Trigram System
+* @korean 자세전환계산기
+*/
+var TransitionCalculator = class {
+	calculateBaseCost(from, to) {
+		if (from === to) return {
+			ki: 0,
+			stamina: 0,
+			timeMilliseconds: 0
+		};
+		return {
+			ki: 10,
+			stamina: 15,
+			timeMilliseconds: 500
+		};
+	}
+	generateTransitionRule(from, to) {
+		return {
+			from,
+			to,
+			cost: this.calculateBaseCost(from, to),
+			effectiveness: 1,
+			conditions: [],
+			description: {
+				korean: `${from}에서 ${to}로 전환`,
+				english: `Transition from ${from} to ${to}`
+			}
+		};
+	}
+	/**
+	* Calculate the cost of transitioning between stances
+	*
+	* **Korean**: 자세 전환 비용 계산
+	*
+	* Calculates ki, stamina, and time costs based on stance distance.
+	* Uses animation system's transition configurations for accurate timing.
+	*
+	* @param from - Source stance
+	* @param to - Target stance
+	* @returns Transition cost breakdown
+	*
+	* @korean 자세전환비용계산
+	*/
+	static calculateCost(from, to) {
+		if (from === to) return {
+			ki: 0,
+			stamina: 0,
+			timeMilliseconds: 0
+		};
+		const timeMs = getStanceTransition(from, to)?.duration ?? 600;
+		const baseCost = {
+			ki: 15,
+			stamina: 10,
+			timeMilliseconds: timeMs
+		};
+		const modifier = this.getAdjacencyModifier(from, to);
+		return {
+			ki: Math.floor(baseCost.ki * modifier),
+			stamina: Math.floor(baseCost.stamina * modifier),
+			timeMilliseconds: timeMs
+		};
+	}
+	/**
+	* Check if a transition is valid for a player
+	*/
+	static canTransition(from, to, player) {
+		const cost = this.calculateCost(from, to);
+		return player.ki >= cost.ki && player.stamina >= cost.stamina;
+	}
+	/**
+	* Check if transition is valid based on player state
+	*/
+	static isTransitionValid(from, to, player) {
+		return this.canTransition(from, to, player);
+	}
+	/**
+	* Get Ki cost for transition
+	*/
+	static getKiCost(from, to, _player) {
+		return this.calculateCost(from, to).ki;
+	}
+	/**
+	* Get Stamina cost for transition
+	*/
+	static getStaminaCost(from, to, _player) {
+		return this.calculateCost(from, to).stamina;
+	}
+	/**
+	* Get transition time
+	*/
+	static getTransitionTime(from, to, _player) {
+		return this.calculateCost(from, to).timeMilliseconds;
+	}
+	/**
+	* Get adjacency modifier for stance transitions
+	*
+	* **Korean**: 인접도 수정자
+	*
+	* Uses the animation system's distance calculation for consistency.
+	* Adjacent stances (distance 1) get 0.7x cost, others get 1.0x cost.
+	*
+	* @param from - Source stance
+	* @param to - Target stance
+	* @returns Cost modifier (0.7 for adjacent, 1.0 for distant)
+	*
+	* @korean 인접도수정자
+	*/
+	static getAdjacencyModifier(from, to) {
+		const distance = calculateStanceDistance(from, to);
+		if (distance === 1) return .7;
+		if (distance === 2) return .85;
+		return 1;
+	}
+	/**
+	* Get the shortest transition path between stances
+	*
+	* **Korean**: 최단 전환 경로
+	*
+	* For direct transitions, returns [from, to].
+	* For indirect transitions, may include intermediate stances for smoother animation.
+	*
+	* @param from - Source stance
+	* @param to - Target stance
+	* @returns Array of stances in transition path
+	*
+	* @example
+	* ```typescript
+	* // Adjacent stances - direct path
+	* getTransitionPath(TrigramStance.GEON, TrigramStance.TAE);
+	* // Returns: ["geon", "tae"]
+	*
+	* // Opposite stances - may use intermediate
+	* getTransitionPath(TrigramStance.GEON, TrigramStance.GON);
+	* // Returns: ["geon", "gon"] (direct is shortest even though opposite)
+	* ```
+	*
+	* @korean 최단전환경로
+	*/
+	static getTransitionPath(from, to) {
+		if (from === to) return [from];
+		return [from, to];
+	}
+	/**
+	* Get transition type for a stance change
+	*
+	* **Korean**: 전환 유형 가져오기
+	*
+	* Determines if transition is direct (adjacent), indirect (opposite), or self.
+	*
+	* @param from - Source stance
+	* @param to - Target stance
+	* @returns Transition type classification
+	*
+	* @korean 전환유형가져오기
+	*/
+	static getTransitionType(from, to) {
+		return determineTransitionType(from, to);
+	}
+	/**
+	* Calculate stance distance around the wheel
+	*
+	* **Korean**: 자세 거리 계산
+	*
+	* Returns the number of steps between stances on the octagonal wheel.
+	*
+	* @param from - Source stance
+	* @param to - Target stance
+	* @returns Distance (0-4)
+	*
+	* @korean 자세거리계산
+	*/
+	static getStanceDistance(from, to) {
+		return calculateStanceDistance(from, to);
+	}
+	/**
+	* Calculate total cost for a transition path
+	*/
+	static calculatePathCost(path) {
+		if (path.length <= 1) return {
+			ki: 0,
+			stamina: 0,
+			timeMilliseconds: 0
+		};
+		const totalCost = {
+			ki: 0,
+			stamina: 0,
+			timeMilliseconds: 0
+		};
+		for (let i = 0; i < path.length - 1; i++) {
+			const stepCost = this.calculateCost(path[i], path[i + 1]);
+			totalCost.ki += stepCost.ki;
+			totalCost.stamina += stepCost.stamina;
+			totalCost.timeMilliseconds += stepCost.timeMilliseconds;
+		}
+		return totalCost;
+	}
+	/**
+	* Get all valid transitions from a stance
+	*/
+	static getValidTransitions(from, player) {
+		const transitions = [];
+		for (const to of Object.values(TrigramStance)) if (this.isTransitionValid(from, to, player)) {
+			const cost = this.calculateCost(from, to);
+			transitions.push({
+				from,
+				to,
+				cost,
+				effectiveness: 1,
+				conditions: [],
+				description: {
+					korean: `${from}에서 ${to}로`,
+					english: `From ${from} to ${to}`
+				}
+			});
+		}
+		return transitions;
+	}
+};
+//#endregion
+export { TransitionCalculator };
+
+//# sourceMappingURL=TransitionCalculator.js.map

package/lib/systems/trigram/TransitionCalculator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TransitionCalculator.js","names":[],"sources":["../../../src/systems/trigram/TransitionCalculator.ts"],"sourcesContent":["import { TrigramStance } from \"../../types\";\nimport { TrigramStance as TrigramStanceEnum } from \"../../types/common\";\nimport {\n  calculateStanceDistance,\n  determineTransitionType,\n  getStanceTransition,\n  type StanceTransitionType,\n} from \"../animation/core/AnimationTransitions\";\nimport { PlayerState } from \"../player\";\nimport { TrigramTransitionCost, TrigramTransitionRule } from \"./types\";\n\n/**\n * Calculator for trigram stance transition costs and validation\n *\n * **Korean**: 자세 전환 계산기\n *\n * Calculates costs, paths, and validation for transitions between trigram stances.\n * Integrates with the animation system's stance transition matrix.\n *\n * @category Trigram System\n * @korean 자세전환계산기\n */\nexport class TransitionCalculator {\n  private calculateBaseCost(\n    from: TrigramStance,\n    to: TrigramStance\n  ): TrigramTransitionCost {\n    if (from === to) {\n      return { ki: 0, stamina: 0, timeMilliseconds: 0 };\n    }\n\n    return { ki: 10, stamina: 15, timeMilliseconds: 500 };\n  }\n\n  generateTransitionRule(\n    from: TrigramStance,\n    to: TrigramStance\n  ): TrigramTransitionRule {\n    const cost = this.calculateBaseCost(from, to);\n\n    return {\n      from,\n      to,\n      cost,\n      effectiveness: 1.0, // Fix: Add missing effectiveness property\n      conditions: [],\n      description: {\n        korean: `${from}에서 ${to}로 전환`,\n        english: `Transition from ${from} to ${to}`,\n      },\n    };\n  }\n\n  /**\n   * Calculate the cost of transitioning between stances\n   *\n   * **Korean**: 자세 전환 비용 계산\n   *\n   * Calculates ki, stamina, and time costs based on stance distance.\n   * Uses animation system's transition configurations for accurate timing.\n   *\n   * @param from - Source stance\n   * @param to - Target stance\n   * @returns Transition cost breakdown\n   *\n   * @korean 자세전환비용계산\n   */\n  static calculateCost(\n    from: TrigramStance,\n    to: TrigramStance\n  ): TrigramTransitionCost {\n    if (from === to) {\n      return { ki: 0, stamina: 0, timeMilliseconds: 0 };\n    }\n\n    // Get transition from animation system for accurate timing\n    const transition = getStanceTransition(from, to);\n    const timeMs = transition?.duration ?? 600;\n\n    const baseCost = { ki: 15, stamina: 10, timeMilliseconds: timeMs };\n    const modifier = this.getAdjacencyModifier(from, to);\n\n    return {\n      ki: Math.floor(baseCost.ki * modifier),\n      stamina: Math.floor(baseCost.stamina * modifier),\n      timeMilliseconds: timeMs, // Use actual transition duration\n    };\n  }\n\n  /**\n   * Check if a transition is valid for a player\n   */\n  static canTransition(\n    from: TrigramStance,\n    to: TrigramStance,\n    player: PlayerState\n  ): boolean {\n    const cost = this.calculateCost(from, to);\n    return player.ki >= cost.ki && player.stamina >= cost.stamina;\n  }\n\n  /**\n   * Check if transition is valid based on player state\n   */\n  static isTransitionValid(\n    from: TrigramStance,\n    to: TrigramStance,\n    player: PlayerState\n  ): boolean {\n    return this.canTransition(from, to, player);\n  }\n\n  /**\n   * Get Ki cost for transition\n   */\n  static getKiCost(\n    from: TrigramStance,\n    to: TrigramStance,\n    _player: PlayerState\n  ): number {\n    return this.calculateCost(from, to).ki;\n  }\n\n  /**\n   * Get Stamina cost for transition\n   */\n  static getStaminaCost(\n    from: TrigramStance,\n    to: TrigramStance,\n    _player: PlayerState\n  ): number {\n    return this.calculateCost(from, to).stamina;\n  }\n\n  /**\n   * Get transition time\n   */\n  static getTransitionTime(\n    from: TrigramStance,\n    to: TrigramStance,\n    _player: PlayerState\n  ): number {\n    return this.calculateCost(from, to).timeMilliseconds; // Fix property name\n  }\n\n  /**\n   * Get adjacency modifier for stance transitions\n   *\n   * **Korean**: 인접도 수정자\n   *\n   * Uses the animation system's distance calculation for consistency.\n   * Adjacent stances (distance 1) get 0.7x cost, others get 1.0x cost.\n   *\n   * @param from - Source stance\n   * @param to - Target stance\n   * @returns Cost modifier (0.7 for adjacent, 1.0 for distant)\n   *\n   * @korean 인접도수정자\n   */\n  private static getAdjacencyModifier(\n    from: TrigramStance,\n    to: TrigramStance\n  ): number {\n    const distance = calculateStanceDistance(from, to);\n\n    // Adjacent stances (distance 1) have reduced cost\n    if (distance === 1) return 0.7;\n\n    // Near-adjacent (distance 2) have slightly reduced cost\n    if (distance === 2) return 0.85;\n\n    // Distant/opposite stances have full cost\n    return 1.0;\n  }\n\n  /**\n   * Get the shortest transition path between stances\n   *\n   * **Korean**: 최단 전환 경로\n   *\n   * For direct transitions, returns [from, to].\n   * For indirect transitions, may include intermediate stances for smoother animation.\n   *\n   * @param from - Source stance\n   * @param to - Target stance\n   * @returns Array of stances in transition path\n   *\n   * @example\n   * ```typescript\n   * // Adjacent stances - direct path\n   * getTransitionPath(TrigramStance.GEON, TrigramStance.TAE);\n   * // Returns: [\"geon\", \"tae\"]\n   *\n   * // Opposite stances - may use intermediate\n   * getTransitionPath(TrigramStance.GEON, TrigramStance.GON);\n   * // Returns: [\"geon\", \"gon\"] (direct is shortest even though opposite)\n   * ```\n   *\n   * @korean 최단전환경로\n   */\n  static getTransitionPath(\n    from: TrigramStance,\n    to: TrigramStance\n  ): TrigramStance[] {\n    if (from === to) return [from];\n\n    // For all transitions, direct path is used\n    // The animation system handles the complexity with keyframes\n    return [from, to];\n  }\n\n  /**\n   * Get transition type for a stance change\n   *\n   * **Korean**: 전환 유형 가져오기\n   *\n   * Determines if transition is direct (adjacent), indirect (opposite), or self.\n   *\n   * @param from - Source stance\n   * @param to - Target stance\n   * @returns Transition type classification\n   *\n   * @korean 전환유형가져오기\n   */\n  static getTransitionType(\n    from: TrigramStance,\n    to: TrigramStance\n  ): StanceTransitionType {\n    return determineTransitionType(from, to);\n  }\n\n  /**\n   * Calculate stance distance around the wheel\n   *\n   * **Korean**: 자세 거리 계산\n   *\n   * Returns the number of steps between stances on the octagonal wheel.\n   *\n   * @param from - Source stance\n   * @param to - Target stance\n   * @returns Distance (0-4)\n   *\n   * @korean 자세거리계산\n   */\n  static getStanceDistance(from: TrigramStance, to: TrigramStance): number {\n    return calculateStanceDistance(from, to);\n  }\n\n  /**\n   * Calculate total cost for a transition path\n   */\n  static calculatePathCost(path: TrigramStance[]): TrigramTransitionCost {\n    if (path.length <= 1) {\n      return { ki: 0, stamina: 0, timeMilliseconds: 0 }; // Fix: Use timeMilliseconds\n    }\n\n    const totalCost = { ki: 0, stamina: 0, timeMilliseconds: 0 };\n\n    for (let i = 0; i < path.length - 1; i++) {\n      const stepCost = this.calculateCost(path[i], path[i + 1]);\n      totalCost.ki += stepCost.ki;\n      totalCost.stamina += stepCost.stamina;\n      totalCost.timeMilliseconds += stepCost.timeMilliseconds;\n    }\n\n    return totalCost;\n  }\n\n  /**\n   * Get all valid transitions from a stance\n   */\n  static getValidTransitions(\n    from: TrigramStance,\n    player: PlayerState\n  ): TrigramTransitionRule[] {\n    const transitions: TrigramTransitionRule[] = [];\n\n    for (const to of Object.values(TrigramStanceEnum)) {\n      if (this.isTransitionValid(from, to, player)) {\n        const cost = this.calculateCost(from, to);\n\n        transitions.push({\n          from,\n          to,\n          cost,\n          effectiveness: 1.0, // Add missing property\n          conditions: [],\n          description: {\n            korean: `${from}에서 ${to}로`,\n            english: `From ${from} to ${to}`,\n          },\n        });\n      }\n    }\n\n    return transitions;\n  }\n}\n"],"mappings":"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"}

package/lib/systems/trigram/TrigramCalculator.d.ts

@@ -0,0 +1,63 @@
+import { TrigramStance } from "../../types/common";
+import { StanceLaterality } from "./types";
+/**
+ * Enhanced stance effectiveness matrix for Korean martial arts
+ * Based on traditional I-Ching trigram relationships
+ */
+declare const STANCE_EFFECTIVENESS_MATRIX: Record<TrigramStance, Partial<Record<TrigramStance, number>>>;
+export declare class TrigramCalculator {
+    /**
+     * Calculate effectiveness of one stance against another
+     */
+    calculateStanceEffectiveness(attackerStance: TrigramStance, defenderStance: TrigramStance): number;
+    /**
+     * Get the optimal counter stance for a given stance
+     */
+    getCounterStance(targetStance: TrigramStance): TrigramStance;
+    /**
+     * Calculate transition difficulty between stances
+     */
+    calculateTransitionDifficulty(fromStance: TrigramStance, toStance: TrigramStance): number;
+    /**
+     * Calculate stance effectiveness between attacker and defender
+     */
+    static calculateStanceEffectiveness(attackerStance: TrigramStance, defenderStance: TrigramStance): number;
+    /**
+     * Get optimal counter stance against opponent stance
+     */
+    static getCounterStance(opponentStance: TrigramStance): TrigramStance;
+    /**
+     * Calculate difficulty of transitioning between stances
+     */
+    static calculateTransitionDifficulty(fromStance: TrigramStance, toStance: TrigramStance): number;
+    /**
+     * Calculate laterality modifier based on stance matching.
+     *
+     * In Korean martial arts, matched stances (both fighters in same laterality)
+     * create tactical advantages for mid-level attacks as centerlines are more exposed.
+     * Mismatched stances (opposite laterality) provide defensive advantages as lead guards
+     * naturally protect the centerline.
+     *
+     * @param attackerLaterality - Attacker's stance laterality (left or right)
+     * @param defenderLaterality - Defender's stance laterality (left or right)
+     * @param attackLevel - Attack level: "high", "mid", or "low"
+     * @returns Damage multiplier (1.0 = neutral, >1.0 = advantage, <1.0 = disadvantage)
+     *
+     * @example
+     * ```typescript
+     * // Matched stances: attacker gains mid-level advantage
+     * const modifier = TrigramCalculator.calculateLateralityModifier("left", "left", "mid");
+     * // Returns 1.15 (+15% effectiveness)
+     *
+     * // Mismatched stances: defender's guard protects centerline
+     * const modifier = TrigramCalculator.calculateLateralityModifier("left", "right", "mid");
+     * // Returns 0.90 (-10% effectiveness)
+     * ```
+     *
+     * @public
+     * @korean 측면성수정자계산
+     */
+    static calculateLateralityModifier(attackerLaterality: StanceLaterality, defenderLaterality: StanceLaterality, attackLevel?: "high" | "mid" | "low"): number;
+}
+export { STANCE_EFFECTIVENESS_MATRIX };
+//# sourceMappingURL=TrigramCalculator.d.ts.map

package/lib/systems/trigram/TrigramCalculator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TrigramCalculator.d.ts","sourceRoot":"","sources":["../../../src/systems/trigram/TrigramCalculator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACnD,OAAO,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAE3C;;;GAGG;AACH,QAAA,MAAM,2BAA2B,EAAE,MAAM,CACvC,aAAa,EACb,OAAO,CAAC,MAAM,CAAC,aAAa,EAAE,MAAM,CAAC,CAAC,CAcvC,CAAC;AAEF,qBAAa,iBAAiB;IAC5B;;OAEG;IACH,4BAA4B,CAC1B,cAAc,EAAE,aAAa,EAC7B,cAAc,EAAE,aAAa,GAC5B,MAAM;IAUT;;OAEG;IACH,gBAAgB,CAAC,YAAY,EAAE,aAAa,GAAG,aAAa;IAmB5D;;OAEG;IACH,6BAA6B,CAC3B,UAAU,EAAE,aAAa,EACzB,QAAQ,EAAE,aAAa,GACtB,MAAM;IA0BT;;OAEG;IACH,MAAM,CAAC,4BAA4B,CACjC,cAAc,EAAE,aAAa,EAC7B,cAAc,EAAE,aAAa,GAC5B,MAAM;IAOT;;OAEG;IACH,MAAM,CAAC,gBAAgB,CAAC,cAAc,EAAE,aAAa,GAAG,aAAa;IAoBrE;;OAEG;IACH,MAAM,CAAC,6BAA6B,CAClC,UAAU,EAAE,aAAa,EACzB,QAAQ,EAAE,aAAa,GACtB,MAAM;IA4BT;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,MAAM,CAAC,2BAA2B,CAChC,kBAAkB,EAAE,gBAAgB,EACpC,kBAAkB,EAAE,gBAAgB,EACpC,WAAW,GAAE,MAAM,GAAG,KAAK,GAAG,KAAa,GAC1C,MAAM;CAuBV;AAED,OAAO,EAAE,2BAA2B,EAAE,CAAC"}