blacktrigram 0.7.2

package/lib/systems/combat/FallIntegration.js

@@ -0,0 +1,100 @@
+import { FALL_TYPE_TO_ANIMATION, isFallState, isGroundState } from "../animation/core/types.js";
+//#region src/systems/combat/FallIntegration.ts
+/**
+* Checks if player should fall and determines fall animation.
+*
+* Integrates BalanceSystem and ConsciousnessSystem to check fall conditions.
+* Returns animation state to transition to if fall is triggered.
+*
+* Korean terminology:
+* - 균형상실 (Gyunhyeong Sangsil): Balance loss
+* - 의식상실 (Uisik Sangsil): Consciousness loss
+*
+* @param player - Player state to check
+* @param combatSystem - Combat system with balance and consciousness systems
+* @param lastImpactAngle - Optional angle of last impact (for consciousness falls)
+* @param attackAngle - Optional angle of current attack (for balance falls)
+* @returns Fall check result with animation state
+*
+* @example
+* ```typescript
+* const fallCheck = checkForFall(player, combatSystem, undefined, attackAngle);
+* if (fallCheck.shouldFall && fallCheck.animationState) {
+*   animationMachine.transitionTo(fallCheck.animationState);
+*   console.log(`Player falling: ${fallCheck.reason}`);
+* }
+* ```
+*
+* @public
+* @korean 낙법확인
+*/
+function checkForFall(player, combatSystem, lastImpactAngle, attackAngle) {
+	const balanceSystem = combatSystem.getBalanceSystem();
+	const consciousnessSystem = combatSystem.getConsciousnessSystem();
+	if (consciousnessSystem.shouldTriggerFall(player)) {
+		const fallType = consciousnessSystem.determineFallType(player, lastImpactAngle);
+		return {
+			shouldFall: true,
+			fallType,
+			animationState: FALL_TYPE_TO_ANIMATION[fallType],
+			reason: "consciousness"
+		};
+	}
+	if (balanceSystem.shouldTriggerFall(player)) {
+		const fallType = attackAngle !== void 0 ? balanceSystem.determineFallType(player, attackAngle, "mid") : balanceSystem.determineFallTypeFromStance(player.currentStance);
+		return {
+			shouldFall: true,
+			fallType,
+			animationState: FALL_TYPE_TO_ANIMATION[fallType],
+			reason: "balance"
+		};
+	}
+	return { shouldFall: false };
+}
+/**
+* Checks if player is currently in a fall or ground animation state.
+*
+* Used to prevent other actions during falls and ground states.
+*
+* @param animationState - Current animation state
+* @returns True if player is falling or on ground
+*
+* @public
+* @korean 낙법중확인
+*/
+function isInFallOrGroundState(animationState) {
+	return isFallState(animationState) || isGroundState(animationState);
+}
+/**
+* Gets Korean description for fall type.
+*
+* @param fallType - Type of fall
+* @returns Korean and English names
+*
+* @public
+* @korean 낙법이름
+*/
+function getFallTypeName(fallType) {
+	return {
+		forward: {
+			korean: "전방낙법",
+			english: "Forward Fall"
+		},
+		backward: {
+			korean: "후방낙법",
+			english: "Backward Fall"
+		},
+		side_left: {
+			korean: "좌측낙법",
+			english: "Left Side Fall"
+		},
+		side_right: {
+			korean: "우측낙법",
+			english: "Right Side Fall"
+		}
+	}[fallType];
+}
+//#endregion
+export { checkForFall, getFallTypeName, isInFallOrGroundState };
+
+//# sourceMappingURL=FallIntegration.js.map

package/lib/systems/combat/FallIntegration.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"FallIntegration.js","names":[],"sources":["../../../src/systems/combat/FallIntegration.ts"],"sourcesContent":["/**\n * Fall Integration Utilities\n *\n * Helper functions to check for fall conditions and determine fall animations\n * based on balance and consciousness systems.\n *\n * @module systems/combat/FallIntegration\n * @category Combat System\n * @korean 낙법통합\n */\n\nimport type { AnimationState, FallType } from \"../animation/core/types\";\nimport {\n  FALL_TYPE_TO_ANIMATION,\n  isFallState,\n  isGroundState,\n} from \"../animation/core/types\";\nimport type { CombatSystem } from \"../CombatSystem\";\nimport type { PlayerState } from \"../player\";\n\n/**\n * Result of fall check with animation state\n * @korean 낙법확인결과\n */\nexport interface FallCheckResult {\n  /** Whether a fall should be triggered */\n  readonly shouldFall: boolean;\n  /** Fall type if falling */\n  readonly fallType?: FallType;\n  /** Animation state to transition to */\n  readonly animationState?: AnimationState;\n  /** Reason for fall */\n  readonly reason?: \"balance\" | \"consciousness\";\n}\n\n/**\n * Checks if player should fall and determines fall animation.\n *\n * Integrates BalanceSystem and ConsciousnessSystem to check fall conditions.\n * Returns animation state to transition to if fall is triggered.\n *\n * Korean terminology:\n * - 균형상실 (Gyunhyeong Sangsil): Balance loss\n * - 의식상실 (Uisik Sangsil): Consciousness loss\n *\n * @param player - Player state to check\n * @param combatSystem - Combat system with balance and consciousness systems\n * @param lastImpactAngle - Optional angle of last impact (for consciousness falls)\n * @param attackAngle - Optional angle of current attack (for balance falls)\n * @returns Fall check result with animation state\n *\n * @example\n * ```typescript\n * const fallCheck = checkForFall(player, combatSystem, undefined, attackAngle);\n * if (fallCheck.shouldFall && fallCheck.animationState) {\n *   animationMachine.transitionTo(fallCheck.animationState);\n *   console.log(`Player falling: ${fallCheck.reason}`);\n * }\n * ```\n *\n * @public\n * @korean 낙법확인\n */\nexport function checkForFall(\n  player: PlayerState,\n  combatSystem: CombatSystem,\n  lastImpactAngle?: number,\n  attackAngle?: number\n): FallCheckResult {\n  const balanceSystem = combatSystem.getBalanceSystem();\n  const consciousnessSystem = combatSystem.getConsciousnessSystem();\n\n  // Check consciousness first (higher priority - complete loss of control)\n  if (consciousnessSystem.shouldTriggerFall(player)) {\n    const fallType = consciousnessSystem.determineFallType(\n      player,\n      lastImpactAngle\n    );\n    return {\n      shouldFall: true,\n      fallType,\n      animationState: FALL_TYPE_TO_ANIMATION[fallType],\n      reason: \"consciousness\",\n    };\n  }\n\n  // Check balance (lower priority - still some control)\n  if (balanceSystem.shouldTriggerFall(player)) {\n    // Use attack angle if available, otherwise use stance-based fall\n    const fallType =\n      attackAngle !== undefined\n        ? balanceSystem.determineFallType(player, attackAngle, \"mid\")\n        : balanceSystem.determineFallTypeFromStance(player.currentStance);\n\n    return {\n      shouldFall: true,\n      fallType,\n      animationState: FALL_TYPE_TO_ANIMATION[fallType],\n      reason: \"balance\",\n    };\n  }\n\n  // No fall condition met\n  return {\n    shouldFall: false,\n  };\n}\n\n/**\n * Checks if player is currently in a fall or ground animation state.\n *\n * Used to prevent other actions during falls and ground states.\n *\n * @param animationState - Current animation state\n * @returns True if player is falling or on ground\n *\n * @public\n * @korean 낙법중확인\n */\nexport function isInFallOrGroundState(animationState: AnimationState): boolean {\n  return isFallState(animationState) || isGroundState(animationState);\n}\n\n/**\n * Gets Korean description for fall type.\n *\n * @param fallType - Type of fall\n * @returns Korean and English names\n *\n * @public\n * @korean 낙법이름\n */\nexport function getFallTypeName(fallType: FallType): {\n  korean: string;\n  english: string;\n} {\n  const names: Record<FallType, { korean: string; english: string }> = {\n    forward: { korean: \"전방낙법\", english: \"Forward Fall\" },\n    backward: { korean: \"후방낙법\", english: \"Backward Fall\" },\n    side_left: { korean: \"좌측낙법\", english: \"Left Side Fall\" },\n    side_right: { korean: \"우측낙법\", english: \"Right Side Fall\" },\n  };\n\n  return names[fallType];\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+DA,SAAgB,aACd,QACA,cACA,iBACA,aACiB;CACjB,MAAM,gBAAgB,aAAa,kBAAkB;CACrD,MAAM,sBAAsB,aAAa,wBAAwB;AAGjE,KAAI,oBAAoB,kBAAkB,OAAO,EAAE;EACjD,MAAM,WAAW,oBAAoB,kBACnC,QACA,gBACD;AACD,SAAO;GACL,YAAY;GACZ;GACA,gBAAgB,uBAAuB;GACvC,QAAQ;GACT;;AAIH,KAAI,cAAc,kBAAkB,OAAO,EAAE;EAE3C,MAAM,WACJ,gBAAgB,KAAA,IACZ,cAAc,kBAAkB,QAAQ,aAAa,MAAM,GAC3D,cAAc,4BAA4B,OAAO,cAAc;AAErE,SAAO;GACL,YAAY;GACZ;GACA,gBAAgB,uBAAuB;GACvC,QAAQ;GACT;;AAIH,QAAO,EACL,YAAY,OACb;;;;;;;;;;;;;AAcH,SAAgB,sBAAsB,gBAAyC;AAC7E,QAAO,YAAY,eAAe,IAAI,cAAc,eAAe;;;;;;;;;;;AAYrE,SAAgB,gBAAgB,UAG9B;AAQA,QAPqE;EACnE,SAAS;GAAE,QAAQ;GAAQ,SAAS;GAAgB;EACpD,UAAU;GAAE,QAAQ;GAAQ,SAAS;GAAiB;EACtD,WAAW;GAAE,QAAQ;GAAQ,SAAS;GAAkB;EACxD,YAAY;GAAE,QAAQ;GAAQ,SAAS;GAAmB;EAC3D,CAEY"}

package/lib/systems/combat/GrappleSystem.d.ts

@@ -0,0 +1,264 @@
+/**
+ * Grappling System for Korean Martial Arts Combat
+ *
+ * **Korean**: 잡기 시스템 (Grapple System)
+ *
+ * Implements realistic grappling and takedown mechanics based on:
+ * - **Hapkido (합기도)**: Joint locks and control techniques
+ * - **Ssireum (씨름)**: Traditional Korean wrestling
+ * - **GON Stance (곤괘)**: Earth stance grounding and control
+ *
+ * ## Core Mechanics
+ *
+ * 1. **Grab Initiation**: Establish grip on opponent's limb/body
+ * 2. **Control Duration**: Maintain control with stamina cost
+ * 3. **Grip Strength**: Affects escape difficulty and follow-up options
+ * 4. **Escape Mechanics**: Based on strength, technique, and stamina
+ * 5. **Follow-up Techniques**: Throws, takedowns, joint locks from control
+ *
+ * ## Phase 2 Enhancement
+ *
+ * Enhanced with Gon (Earth) trigram metadata integration:
+ * - Uses `controlDuration` from ExtendedGonTechnique
+ * - Supports authentic Ssireum/Hapkido control durations
+ * - Maintains backward compatibility with non-Gon techniques
+ *
+ * @module systems/combat/GrappleSystem
+ * @category Combat System
+ * @korean 잡기시스템
+ */
+import type { PlayerState } from "../player";
+import { GrappleControl, GrappleTarget } from "../../types";
+import type { KoreanTechnique } from "../vitalpoint/types";
+/**
+ * Configuration for grappling mechanics.
+ *
+ * **Korean**: 잡기 설정 (Grapple Configuration)
+ */
+export interface GrappleConfig {
+    /** Base stamina cost per second to maintain control */
+    readonly baseStaminaCostPerSecond: number;
+    /** Minimum grip strength to maintain control */
+    readonly minGripStrength: number;
+    /** Maximum grip strength value */
+    readonly maxGripStrength: number;
+    /** Base escape difficulty multiplier */
+    readonly baseEscapeDifficulty: number;
+    /** Stamina cost to attempt escape */
+    readonly escapeStaminaCost: number;
+    /** Minimum duration before escape is possible (ms) */
+    readonly minControlDuration: number;
+}
+/**
+ * Default grappling configuration values.
+ */
+export declare const DEFAULT_GRAPPLE_CONFIG: GrappleConfig;
+/**
+ * Grapple attempt result.
+ *
+ * **Korean**: 잡기 시도 결과 (Grapple Attempt Result)
+ */
+export interface GrappleAttemptResult {
+    /** Whether the grapple was successful */
+    readonly success: boolean;
+    /** New grapple control state if successful */
+    readonly grappleControl?: GrappleControl;
+    /** Reason for failure if unsuccessful */
+    readonly reason?: string;
+    /** Stamina cost for the attempt */
+    readonly staminaCost: number;
+}
+/**
+ * Escape attempt result.
+ *
+ * **Korean**: 탈출 시도 결과 (Escape Attempt Result)
+ */
+export interface EscapeAttemptResult {
+    /** Whether the escape was successful */
+    readonly success: boolean;
+    /** Updated grapple control state */
+    readonly grappleControl: GrappleControl | null;
+    /** Reason for failure if unsuccessful */
+    readonly reason?: string;
+    /** Stamina cost for the attempt */
+    readonly staminaCost: number;
+}
+/**
+ * Grappling System for control and hold mechanics.
+ *
+ * **Korean**: 잡기 시스템 (Grapple System)
+ *
+ * Manages grappling state between combatants, including grip strength,
+ * control duration, escape mechanics, and follow-up techniques.
+ */
+export declare class GrappleSystem {
+    private readonly config;
+    constructor(config?: Partial<GrappleConfig>);
+    /**
+     * Attempt to initiate a grapple on target.
+     *
+     * **Korean**: 잡기 시도 (Attempt Grapple)
+     *
+     * @param attacker - Player attempting the grapple
+     * @param defender - Target player
+     * @param target - Body part to grapple
+     * @param currentTime - Current game time in milliseconds
+     * @returns Result of the grapple attempt
+     */
+    attemptGrapple(attacker: PlayerState, defender: PlayerState, target: GrappleTarget, currentTime: number): GrappleAttemptResult;
+    /**
+     * Update grapple control state over time.
+     *
+     * **Korean**: 잡기 업데이트 (Update Grapple)
+     *
+     * @param grappleControl - Current grapple control state
+     * @param controller - Player maintaining control
+     * @param target - Player being controlled
+     * @param deltaTime - Time elapsed since last update (seconds)
+     * @param currentTime - Current game time in milliseconds
+     * @returns Updated grapple control or null if broken
+     */
+    updateGrapple(grappleControl: GrappleControl, controller: PlayerState, _target: PlayerState, deltaTime: number, currentTime: number): GrappleControl | null;
+    /**
+     * Attempt to escape from a grapple.
+     *
+     * **Korean**: 탈출 시도 (Attempt Escape)
+     *
+     * @param grappleControl - Current grapple control state
+     * @param controller - Player maintaining control
+     * @param target - Player attempting to escape
+     * @returns Result of the escape attempt
+     */
+    attemptEscape(grappleControl: GrappleControl, controller: PlayerState, target: PlayerState): EscapeAttemptResult;
+    /**
+     * Calculate grip strength based on attacker attributes and target.
+     *
+     * **Korean**: 악력 계산 (Calculate Grip Strength)
+     *
+     * @private
+     */
+    private calculateGripStrength;
+    /**
+     * Calculate grapple success chance.
+     *
+     * **Korean**: 잡기 성공률 계산 (Calculate Grapple Success Chance)
+     *
+     * @private
+     */
+    private calculateGrappleSuccessChance;
+    /**
+     * Calculate escape chance from grapple.
+     *
+     * **Korean**: 탈출 성공률 계산 (Calculate Escape Chance)
+     *
+     * @private
+     */
+    private calculateEscapeChance;
+    /**
+     * Calculate stamina cost to maintain control.
+     *
+     * **Korean**: 체력 소모 계산 (Calculate Stamina Cost)
+     *
+     * @private
+     */
+    private calculateStaminaCost;
+    /**
+     * Check if a grapple can be transitioned to a throw.
+     *
+     * **Korean**: 던지기 전환 확인 (Check Throw Transition)
+     *
+     * @param grappleControl - Current grapple control state
+     * @param controller - Player attempting throw
+     * @returns Whether throw transition is possible
+     */
+    canTransitionToThrow(grappleControl: GrappleControl, controller: PlayerState): boolean;
+    /**
+     * Check if a grapple can be transitioned to a joint lock.
+     *
+     * **Korean**: 관절기 전환 확인 (Check Joint Lock Transition)
+     *
+     * @param grappleControl - Current grapple control state
+     * @param controller - Player attempting lock
+     * @returns Whether joint lock transition is possible
+     */
+    canTransitionToJointLock(grappleControl: GrappleControl, controller: PlayerState): boolean;
+    /**
+     * Get technique-specific control duration from Gon metadata.
+     *
+     * **Korean**: 기술별 제어 시간 조회 (Get Technique Control Duration)
+     *
+     * Retrieves the post-throw positional advantage duration from
+     * ExtendedGonTechnique metadata. Falls back to default duration
+     * if technique doesn't have Gon-specific enhancements.
+     *
+     * **Control Duration Philosophy**:
+     * - Traditional Ssireum techniques (800-2000ms) provide longer control
+     * - Aggressive slam techniques (800-1200ms) provide brief control
+     * - Sacrifice throws (1500-2000ms) provide extended ground control
+     *
+     * **Use Cases**:
+     * - Determining follow-up attack windows after throws
+     * - Calculating defender recovery time before counterattack
+     * - Applying post-throw positional advantage in game state
+     *
+     * @param technique - Korean martial arts technique (checks for ExtendedGonTechnique)
+     * @param defaultDuration - Fallback duration if technique has no metadata (default: 1000ms)
+     * @returns Control duration in milliseconds
+     *
+     * @example
+     * ```typescript
+     * const controlTime = grappleSystem.getTechniqueControlDuration(
+     *   ssireumThrowTechnique, // controlDuration: 1800
+     *   1000 // default fallback
+     * );
+     * // Result: 1800ms (uses technique metadata)
+     * ```
+     *
+     * @public
+     * @korean 기술별제어시간조회
+     */
+    getTechniqueControlDuration(technique: KoreanTechnique, defaultDuration?: number): number;
+    /**
+     * Apply post-throw control advantage window.
+     *
+     * **Korean**: 던지기 후 우세 적용 (Apply Post-Throw Advantage)
+     *
+     * Creates a control advantage state after a successful throw,
+     * using the technique's `controlDuration` to determine how long
+     * the attacker maintains positional dominance.
+     *
+     * **Advantage Effects**:
+     * - Attacker gains priority for follow-up attacks
+     * - Defender must wait for control duration to expire
+     * - Applies to throw transitions from grapple control
+     *
+     * @param technique - Throw technique executed
+     * @param attackerId - Player who executed throw
+     * @param defenderId - Player who was thrown
+     * @param currentTime - Current game time in milliseconds
+     * @returns Control advantage state with duration from technique metadata
+     *
+     * @example
+     * ```typescript
+     * const advantage = grappleSystem.applyPostThrowAdvantage(
+     *   ssireumThrowTechnique,
+     *   "player1",
+     *   "player2",
+     *   Date.now()
+     * );
+     * // advantage.duration = 1800ms (from technique metadata)
+     * ```
+     *
+     * @public
+     * @korean 던지기후우세적용
+     */
+    applyPostThrowAdvantage(technique: KoreanTechnique, attackerId: string, defenderId: string, currentTime: number): {
+        controllerId: string;
+        targetId: string;
+        duration: number;
+        startTime: number;
+        endTime: number;
+    };
+}
+export default GrappleSystem;
+//# sourceMappingURL=GrappleSystem.d.ts.map

package/lib/systems/combat/GrappleSystem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GrappleSystem.d.ts","sourceRoot":"","sources":["../../../src/systems/combat/GrappleSystem.ts"],"names":[],"mappings":"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"}