blacktrigram 0.7.2

package/lib/systems/index.js

@@ -0,0 +1,281 @@
+import { __exportAll } from "../_virtual/_rolldown/runtime.js";
+import { TRIGRAM_DATA, TRIGRAM_STANCES_ORDER, combineStanceWithSide, parseStanceWithSide } from "./trigram/types.js";
+import GAME_CONFIG, { ANIMATION_TIMINGS, AUDIO_DEFAULTS, BASE_PLAYER_STATS, CANVAS_ASPECT_RATIO, CENTER_POSITION_X, COMBAT_AUDIO_MAP, COMBAT_CONFIG, COMBAT_CONSTANTS, COMBAT_CONTROLS, COMBAT_PHASES, COMBAT_RANGES, COMBAT_STATE_MACHINE, COMBAT_TIMING, DAMAGE_CONSTANTS, DAMAGE_TYPES, DIFFICULTY_SETTINGS, EFFECTIVENESS_MODIFIERS, ENHANCED_DAMAGE_CONSTANTS, FRAME_TIME, GAME_METADATA, GAME_MODE_CONFIG, GAME_PHASES, GAME_STATES, HALF_CANVAS_HEIGHT, HALF_CANVAS_WIDTH, HIT_DETECTION, INPUT_CONSTANTS, KEYBOARD_MAPPING, MARTIAL_ARTS_CONFIG, PERFORMANCE_CONFIG, PERFORMANCE_THRESHOLDS, PLAYER_ARCHETYPES_DATA, PLAYER_COLORS, PLAYER_DISTANCE, RESOURCE_COSTS, STATUS_DURATIONS, TECHNIQUE_RESULTS, TICK_RATE, TRAINING_COMBAT_SETTINGS, TRAINING_CONFIG, TRAINING_STATE_MACHINE, UI_LAYOUT, VISUAL_EFFECTS, getStanceFromKey } from "./types.js";
+import { GEON_TECHNIQUES } from "./trigram/techniques/GeonTechniques.js";
+import { JIN_TECHNIQUES } from "./trigram/techniques/JinTechniques.js";
+import { LI_TECHNIQUES } from "./trigram/techniques/LiTechniques.js";
+import { TAE_TECHNIQUES } from "./trigram/techniques/TaeTechniques.js";
+import { GAM_TECHNIQUES, GAM_TECHNIQUE_COUNT, getGamTechniqueById, getGamTechniquesByType } from "./trigram/techniques/GamTechniques.js";
+import { GAN_TECHNIQUES, GAN_TECHNIQUE_COUNT, getGanTechniqueById, getGanTechniquesByType } from "./trigram/techniques/GanTechniques.js";
+import { GON_TECHNIQUES, GON_TECHNIQUE_COUNT, getGonTechniqueById, getGonTechniquesByType } from "./trigram/techniques/GonTechniques.js";
+import { SON_TECHNIQUES, SON_TECHNIQUE_COUNT, getSonTechniqueById, getSonTechniquesByType } from "./trigram/techniques/SonTechniques.js";
+import { DARK_OPS_ARCHETYPE_BONUSES, DARK_OPS_NIGHT_BONUS, DARK_OPS_SPECIAL_EFFECTS, DARK_OPS_TECHNIQUES, DARK_OPS_TECHNIQUE_COUNT, DARK_OPS_UNITS, getDarkOpsArchetypeBonus, getDarkOpsTechniqueById, getDarkOpsTechniquesByUnit } from "./trigram/techniques/DarkOpsTechniques.js";
+import { DAMAGE_TYPE_EFFECTIVENESS, KOREAN_TECHNIQUE_CATEGORIES, TECHNIQUE_DIFFICULTY_LEVELS, TECHNIQUE_MODIFIERS, TECHNIQUE_NAMING, TECHNIQUE_PROPERTIES, TRIGRAM_TECHNIQUE_PROPERTIES, calculateDamageEffectiveness, getTrigramKey, getTrigramProperties } from "./trigram/techniques/TechniqueConfig.js";
+import { TRIGRAM_TECHNIQUES, getAllTechniques, getTechniqueById, getTechniqueCountByStance, getTotalTechniqueCount } from "./trigram/techniques/index.js";
+import { KoreanTechniquesSystem, TECHNIQUE_EFFECTIVENESS_MATRIX, getTechniquesByStance } from "./trigram/KoreanTechniques.js";
+import { EffectIntensity, HitEffectEnum, HitEffectType } from "./effects.js";
+import BalanceSystem, { BalanceLevel } from "./combat/BalanceSystem.js";
+import ConsciousnessSystem, { ConsciousnessLevel } from "./combat/ConsciousnessSystem.js";
+import { extractVitalPointCategory, formatPainConsciousnessDisplay, getPainConsciousnessStatus, getRecommendedRecoveryTime, getShockPainRemainingDuration, isHeadTraumaHit, isShockPainActive } from "./combat/painConsciousnessUtils.js";
+import PainResponseSystem, { PainLevel } from "./combat/PainResponseSystem.js";
+import { KoreanCulture } from "./trigram/KoreanCulture.js";
+import { STANCE_EFFECTIVENESS_MATRIX, TrigramCalculator } from "./trigram/TrigramCalculator.js";
+import { StanceManager } from "./trigram/StanceManager.js";
+import { TransitionCalculator } from "./trigram/TransitionCalculator.js";
+import "./trigram/index.js";
+import TrigramSystem, { COUNTER_STANCE_DAMAGE_MULTIPLIER, STANCE_COUNTERS, applyCounterStanceDamage } from "./TrigramSystem.js";
+import { VITAL_POINT_MERIDIAN_MAP, getMeridianMappingStatistics, getMeridiansForVitalPoint, getVitalPointsForMeridian, isVitalPointOnMeridian } from "./vitalpoint/MeridianVitalPointMapping.js";
+import SAMPLE_VITAL_POINTS, { ANATOMICAL_REGIONS_DATA, ELEMENTAL_RELATIONS, ENERGY_MERIDIANS, ENERGY_MERIDIANS_ARRAY, ENHANCED_ANATOMICAL_ZONES, KOREAN_ANATOMICAL_ZONES, KOREAN_ANATOMICAL_ZONES_ARRAY, KoreanAnatomySystem, calculateAnatomicalVulnerability, calculateEnhancedVulnerability, calculateMeridianFlow, createVitalPointEffect, findOptimalVitalPoints, generateMeridianEffects, generateVulnerabilityHeatMap, getAnatomicalZones, getEnhancedZonesByPosition, getMeridian, getMeridiansByElement, getRegionBoundaries, getRegionForPosition, getVitalPointsInRegion, getZoneByPosition, isPointInPolygon, isPositionInEnhancedZone, isPositionInRegion } from "./vitalpoint/KoreanAnatomy.js";
+import VitalPointSystem from "./VitalPointSystem.js";
+import GrappleSystem, { DEFAULT_GRAPPLE_CONFIG } from "./combat/GrappleSystem.js";
+import CombatSystem, { createCombatResult } from "./CombatSystem.js";
+import { AI_PERSONALITIES, ARCHETYPE_BEHAVIORS, followsHonorCode, getAllPersonalities, getArchetypeBehavior, getOptimalRange, getPersonalityByArchetype, getPersonalityByName, getRandomPersonality } from "./ai/AIPersonality.js";
+import { AIComboSystem, ARCHETYPE_SIGNATURE_COMBOS, getNextComboTechnique } from "./ai/ComboSystem.js";
+import { AdaptiveDifficulty, DIFFICULTY_PARAMETERS, DifficultyTier, interpolateDifficultyParameters, skillScoreToTier } from "./ai/AdaptiveDifficulty.js";
+import KOREAN_VITAL_POINTS, { getVitalPointById, getVitalPointsByCategory, getVitalPointsByDifficulty, getVitalPointsByRegion, getVitalPointsBySeverity, getVitalPointsByStance, getVitalPointsStats } from "./vitalpoint/KoreanVitalPoints.js";
+import { AIActionType } from "./ai/types.js";
+import { ARCHETYPE_ENFORCEMENT, enforceArchetypeBehavior, getActionFrequency, getSignatureMove, isActionProhibited, shouldExecuteSignatureMove } from "./ai/ArchetypeEnforcer.js";
+import { AIDecisionTree } from "./ai/DecisionTree.js";
+import TrainingAI from "./ai/TrainingAI.js";
+import "./ai/index.js";
+import TrainingCombatSystem from "./combat/TrainingCombatSystem.js";
+import { isValidArchetype, isVitalPoint, isVitalPointCategory } from "./combat/typeGuards.js";
+import CombatStateSystem, { CombatReadinessState } from "./combat/CombatStateSystem.js";
+import BREAKING_STATUS_EFFECT_IDS, { getAllBreakingStatusEffectIds, isBreakingStatusEffectId } from "./combat/BreakingStatusEffects.js";
+import { calculateBreakingResult, calculateCounterOpportunity, calculateVulnerabilityMultiplier, canExecuteCounter, determineExposedLimb, generateLimbExposureWindow, mapLimbToBreakingTarget } from "./combat/LimbExposureSystem.js";
+import "./combat/index.js";
+import { checkForFall, getFallTypeName, isInFallOrGroundState } from "./combat/FallIntegration.js";
+import { GameEventType } from "./game.js";
+import { LayoutSystem, alignHorizontal, alignVertical, calculateGridPosition, centerElement, defaultLayoutSystem } from "./LayoutSystem.js";
+import DamageCalculator from "./vitalpoint/DamageCalculator.js";
+import HitDetection from "./vitalpoint/HitDetection.js";
+import "./vitalpoint/index.js";
+//#region src/systems/index.ts
+var systems_exports = /* @__PURE__ */ __exportAll({
+	AIActionType: () => AIActionType,
+	AIComboSystem: () => AIComboSystem,
+	AIDecisionTree: () => AIDecisionTree,
+	AI_PERSONALITIES: () => AI_PERSONALITIES,
+	ANATOMICAL_REGIONS_DATA: () => ANATOMICAL_REGIONS_DATA,
+	ANIMATION_TIMINGS: () => ANIMATION_TIMINGS,
+	ARCHETYPE_BEHAVIORS: () => ARCHETYPE_BEHAVIORS,
+	ARCHETYPE_ENFORCEMENT: () => ARCHETYPE_ENFORCEMENT,
+	ARCHETYPE_SIGNATURE_COMBOS: () => ARCHETYPE_SIGNATURE_COMBOS,
+	AUDIO_DEFAULTS: () => AUDIO_DEFAULTS,
+	AdaptiveDifficulty: () => AdaptiveDifficulty,
+	BASE_PLAYER_STATS: () => BASE_PLAYER_STATS,
+	BREAKING_STATUS_EFFECT_IDS: () => BREAKING_STATUS_EFFECT_IDS,
+	BalanceLevel: () => BalanceLevel,
+	BalanceSystem: () => BalanceSystem,
+	CANVAS_ASPECT_RATIO: () => CANVAS_ASPECT_RATIO,
+	CENTER_POSITION_X: () => CENTER_POSITION_X,
+	COMBAT_AUDIO_MAP: () => COMBAT_AUDIO_MAP,
+	COMBAT_CONFIG: () => COMBAT_CONFIG,
+	COMBAT_CONSTANTS: () => COMBAT_CONSTANTS,
+	COMBAT_CONTROLS: () => COMBAT_CONTROLS,
+	COMBAT_PHASES: () => COMBAT_PHASES,
+	COMBAT_RANGES: () => COMBAT_RANGES,
+	COMBAT_STATE_MACHINE: () => COMBAT_STATE_MACHINE,
+	COMBAT_TIMING: () => COMBAT_TIMING,
+	COUNTER_STANCE_DAMAGE_MULTIPLIER: () => COUNTER_STANCE_DAMAGE_MULTIPLIER,
+	CombatReadinessState: () => CombatReadinessState,
+	CombatStateSystem: () => CombatStateSystem,
+	CombatSystem: () => CombatSystem,
+	ConsciousnessLevel: () => ConsciousnessLevel,
+	ConsciousnessSystem: () => ConsciousnessSystem,
+	DAMAGE_CONSTANTS: () => DAMAGE_CONSTANTS,
+	DAMAGE_TYPES: () => DAMAGE_TYPES,
+	DAMAGE_TYPE_EFFECTIVENESS: () => DAMAGE_TYPE_EFFECTIVENESS,
+	DARK_OPS_ARCHETYPE_BONUSES: () => DARK_OPS_ARCHETYPE_BONUSES,
+	DARK_OPS_NIGHT_BONUS: () => DARK_OPS_NIGHT_BONUS,
+	DARK_OPS_SPECIAL_EFFECTS: () => DARK_OPS_SPECIAL_EFFECTS,
+	DARK_OPS_TECHNIQUES: () => DARK_OPS_TECHNIQUES,
+	DARK_OPS_TECHNIQUE_COUNT: () => DARK_OPS_TECHNIQUE_COUNT,
+	DARK_OPS_UNITS: () => DARK_OPS_UNITS,
+	DEFAULT_GAME_SPEED: () => 1,
+	DEFAULT_GRAPPLE_CONFIG: () => DEFAULT_GRAPPLE_CONFIG,
+	DEFAULT_ROW_HEIGHT: () => 100,
+	DIFFICULTY_PARAMETERS: () => DIFFICULTY_PARAMETERS,
+	DIFFICULTY_SETTINGS: () => DIFFICULTY_SETTINGS,
+	DamageCalculator: () => DamageCalculator,
+	DifficultyTier: () => DifficultyTier,
+	EFFECTIVENESS_MODIFIERS: () => EFFECTIVENESS_MODIFIERS,
+	ELEMENTAL_RELATIONS: () => ELEMENTAL_RELATIONS,
+	ENERGY_MERIDIANS: () => ENERGY_MERIDIANS,
+	ENERGY_MERIDIANS_ARRAY: () => ENERGY_MERIDIANS_ARRAY,
+	ENHANCED_ANATOMICAL_ZONES: () => ENHANCED_ANATOMICAL_ZONES,
+	ENHANCED_DAMAGE_CONSTANTS: () => ENHANCED_DAMAGE_CONSTANTS,
+	EffectIntensity: () => EffectIntensity,
+	FRAME_TIME: () => FRAME_TIME,
+	GAME_CONFIG: () => GAME_CONFIG,
+	GAME_METADATA: () => GAME_METADATA,
+	GAME_MODE_CONFIG: () => GAME_MODE_CONFIG,
+	GAME_PHASES: () => GAME_PHASES,
+	GAME_STATES: () => GAME_STATES,
+	GAM_TECHNIQUES: () => GAM_TECHNIQUES,
+	GAM_TECHNIQUE_COUNT: () => GAM_TECHNIQUE_COUNT,
+	GAN_TECHNIQUES: () => GAN_TECHNIQUES,
+	GAN_TECHNIQUE_COUNT: () => GAN_TECHNIQUE_COUNT,
+	GEON_TECHNIQUES: () => GEON_TECHNIQUES,
+	GON_TECHNIQUES: () => GON_TECHNIQUES,
+	GON_TECHNIQUE_COUNT: () => GON_TECHNIQUE_COUNT,
+	GameEventType: () => GameEventType,
+	GrappleSystem: () => GrappleSystem,
+	HALF_CANVAS_HEIGHT: () => HALF_CANVAS_HEIGHT,
+	HALF_CANVAS_WIDTH: () => HALF_CANVAS_WIDTH,
+	HIT_DETECTION: () => HIT_DETECTION,
+	HitDetection: () => HitDetection,
+	HitEffectEnum: () => HitEffectEnum,
+	HitEffectType: () => HitEffectType,
+	INPUT_CONSTANTS: () => INPUT_CONSTANTS,
+	JIN_TECHNIQUES: () => JIN_TECHNIQUES,
+	KEYBOARD_MAPPING: () => KEYBOARD_MAPPING,
+	KOREAN_ANATOMICAL_ZONES: () => KOREAN_ANATOMICAL_ZONES,
+	KOREAN_ANATOMICAL_ZONES_ARRAY: () => KOREAN_ANATOMICAL_ZONES_ARRAY,
+	KOREAN_TECHNIQUE_CATEGORIES: () => KOREAN_TECHNIQUE_CATEGORIES,
+	KOREAN_VITAL_POINTS: () => KOREAN_VITAL_POINTS,
+	KoreanAnatomySystem: () => KoreanAnatomySystem,
+	KoreanCulture: () => KoreanCulture,
+	KoreanTechniquesSystem: () => KoreanTechniquesSystem,
+	LI_TECHNIQUES: () => LI_TECHNIQUES,
+	LayoutSystem: () => LayoutSystem,
+	MARTIAL_ARTS_CONFIG: () => MARTIAL_ARTS_CONFIG,
+	PERFORMANCE_CONFIG: () => PERFORMANCE_CONFIG,
+	PERFORMANCE_THRESHOLDS: () => PERFORMANCE_THRESHOLDS,
+	PLAYER_ARCHETYPES_DATA: () => PLAYER_ARCHETYPES_DATA,
+	PLAYER_COLORS: () => PLAYER_COLORS,
+	PLAYER_DISTANCE: () => PLAYER_DISTANCE,
+	PainLevel: () => PainLevel,
+	PainResponseSystem: () => PainResponseSystem,
+	RESOURCE_COSTS: () => RESOURCE_COSTS,
+	SAMPLE_VITAL_POINTS: () => SAMPLE_VITAL_POINTS,
+	SON_TECHNIQUES: () => SON_TECHNIQUES,
+	SON_TECHNIQUE_COUNT: () => SON_TECHNIQUE_COUNT,
+	STANCE_COUNTERS: () => STANCE_COUNTERS,
+	STANCE_EFFECTIVENESS_MATRIX: () => STANCE_EFFECTIVENESS_MATRIX,
+	STATUS_DURATIONS: () => STATUS_DURATIONS,
+	StanceManager: () => StanceManager,
+	TAE_TECHNIQUES: () => TAE_TECHNIQUES,
+	TECHNIQUE_DIFFICULTY_LEVELS: () => TECHNIQUE_DIFFICULTY_LEVELS,
+	TECHNIQUE_EFFECTIVENESS_MATRIX: () => TECHNIQUE_EFFECTIVENESS_MATRIX,
+	TECHNIQUE_MODIFIERS: () => TECHNIQUE_MODIFIERS,
+	TECHNIQUE_NAMING: () => TECHNIQUE_NAMING,
+	TECHNIQUE_PROPERTIES: () => TECHNIQUE_PROPERTIES,
+	TECHNIQUE_RESULTS: () => TECHNIQUE_RESULTS,
+	TICK_RATE: () => TICK_RATE,
+	TRAINING_COMBAT_SETTINGS: () => TRAINING_COMBAT_SETTINGS,
+	TRAINING_CONFIG: () => TRAINING_CONFIG,
+	TRAINING_STATE_MACHINE: () => TRAINING_STATE_MACHINE,
+	TRIGRAM_DATA: () => TRIGRAM_DATA,
+	TRIGRAM_STANCES_ORDER: () => TRIGRAM_STANCES_ORDER,
+	TRIGRAM_TECHNIQUES: () => TRIGRAM_TECHNIQUES,
+	TRIGRAM_TECHNIQUE_PROPERTIES: () => TRIGRAM_TECHNIQUE_PROPERTIES,
+	TrainingAI: () => TrainingAI,
+	TrainingCombatSystem: () => TrainingCombatSystem,
+	TransitionCalculator: () => TransitionCalculator,
+	TrigramCalculator: () => TrigramCalculator,
+	TrigramSystem: () => TrigramSystem,
+	UI_LAYOUT: () => UI_LAYOUT,
+	VISUAL_EFFECTS: () => VISUAL_EFFECTS,
+	VITAL_POINT_MERIDIAN_MAP: () => VITAL_POINT_MERIDIAN_MAP,
+	VitalPointSystem: () => VitalPointSystem,
+	alignHorizontal: () => alignHorizontal,
+	alignVertical: () => alignVertical,
+	applyCounterStanceDamage: () => applyCounterStanceDamage,
+	calculateAnatomicalVulnerability: () => calculateAnatomicalVulnerability,
+	calculateBreakingResult: () => calculateBreakingResult,
+	calculateCounterOpportunity: () => calculateCounterOpportunity,
+	calculateDamageEffectiveness: () => calculateDamageEffectiveness,
+	calculateEnhancedVulnerability: () => calculateEnhancedVulnerability,
+	calculateGridPosition: () => calculateGridPosition,
+	calculateMeridianFlow: () => calculateMeridianFlow,
+	calculateVulnerabilityMultiplier: () => calculateVulnerabilityMultiplier,
+	canExecuteCounter: () => canExecuteCounter,
+	centerElement: () => centerElement,
+	checkForFall: () => checkForFall,
+	combineStanceWithSide: () => combineStanceWithSide,
+	createCombatResult: () => createCombatResult,
+	createVitalPointEffect: () => createVitalPointEffect,
+	defaultLayoutSystem: () => defaultLayoutSystem,
+	determineExposedLimb: () => determineExposedLimb,
+	enforceArchetypeBehavior: () => enforceArchetypeBehavior,
+	extractVitalPointCategory: () => extractVitalPointCategory,
+	findOptimalVitalPoints: () => findOptimalVitalPoints,
+	followsHonorCode: () => followsHonorCode,
+	formatPainConsciousnessDisplay: () => formatPainConsciousnessDisplay,
+	generateLimbExposureWindow: () => generateLimbExposureWindow,
+	generateMeridianEffects: () => generateMeridianEffects,
+	generateVulnerabilityHeatMap: () => generateVulnerabilityHeatMap,
+	getActionFrequency: () => getActionFrequency,
+	getAllBreakingStatusEffectIds: () => getAllBreakingStatusEffectIds,
+	getAllPersonalities: () => getAllPersonalities,
+	getAllTechniques: () => getAllTechniques,
+	getAnatomicalZones: () => getAnatomicalZones,
+	getArchetypeBehavior: () => getArchetypeBehavior,
+	getDarkOpsArchetypeBonus: () => getDarkOpsArchetypeBonus,
+	getDarkOpsTechniqueById: () => getDarkOpsTechniqueById,
+	getDarkOpsTechniquesByUnit: () => getDarkOpsTechniquesByUnit,
+	getEnhancedZonesByPosition: () => getEnhancedZonesByPosition,
+	getFallTypeName: () => getFallTypeName,
+	getGamTechniqueById: () => getGamTechniqueById,
+	getGamTechniquesByType: () => getGamTechniquesByType,
+	getGanTechniqueById: () => getGanTechniqueById,
+	getGanTechniquesByType: () => getGanTechniquesByType,
+	getGonTechniqueById: () => getGonTechniqueById,
+	getGonTechniquesByType: () => getGonTechniquesByType,
+	getMeridian: () => getMeridian,
+	getMeridianMappingStatistics: () => getMeridianMappingStatistics,
+	getMeridiansByElement: () => getMeridiansByElement,
+	getMeridiansForVitalPoint: () => getMeridiansForVitalPoint,
+	getNextComboTechnique: () => getNextComboTechnique,
+	getOptimalRange: () => getOptimalRange,
+	getPainConsciousnessStatus: () => getPainConsciousnessStatus,
+	getPersonalityByArchetype: () => getPersonalityByArchetype,
+	getPersonalityByName: () => getPersonalityByName,
+	getRandomPersonality: () => getRandomPersonality,
+	getRecommendedRecoveryTime: () => getRecommendedRecoveryTime,
+	getRegionBoundaries: () => getRegionBoundaries,
+	getRegionForPosition: () => getRegionForPosition,
+	getShockPainRemainingDuration: () => getShockPainRemainingDuration,
+	getSignatureMove: () => getSignatureMove,
+	getSonTechniqueById: () => getSonTechniqueById,
+	getSonTechniquesByType: () => getSonTechniquesByType,
+	getStanceFromKey: () => getStanceFromKey,
+	getTechniqueById: () => getTechniqueById,
+	getTechniqueCountByStance: () => getTechniqueCountByStance,
+	getTechniquesByStance: () => getTechniquesByStance,
+	getTotalTechniqueCount: () => getTotalTechniqueCount,
+	getTrigramKey: () => getTrigramKey,
+	getTrigramProperties: () => getTrigramProperties,
+	getVitalPointById: () => getVitalPointById,
+	getVitalPointsByCategory: () => getVitalPointsByCategory,
+	getVitalPointsByDifficulty: () => getVitalPointsByDifficulty,
+	getVitalPointsByRegion: () => getVitalPointsByRegion,
+	getVitalPointsBySeverity: () => getVitalPointsBySeverity,
+	getVitalPointsByStance: () => getVitalPointsByStance,
+	getVitalPointsForMeridian: () => getVitalPointsForMeridian,
+	getVitalPointsInRegion: () => getVitalPointsInRegion,
+	getVitalPointsStats: () => getVitalPointsStats,
+	getZoneByPosition: () => getZoneByPosition,
+	interpolateDifficultyParameters: () => interpolateDifficultyParameters,
+	isActionProhibited: () => isActionProhibited,
+	isBreakingStatusEffectId: () => isBreakingStatusEffectId,
+	isHeadTraumaHit: () => isHeadTraumaHit,
+	isInFallOrGroundState: () => isInFallOrGroundState,
+	isPointInPolygon: () => isPointInPolygon,
+	isPositionInEnhancedZone: () => isPositionInEnhancedZone,
+	isPositionInRegion: () => isPositionInRegion,
+	isShockPainActive: () => isShockPainActive,
+	isValidArchetype: () => isValidArchetype,
+	isVitalPoint: () => isVitalPoint,
+	isVitalPointCategory: () => isVitalPointCategory,
+	isVitalPointOnMeridian: () => isVitalPointOnMeridian,
+	mapLimbToBreakingTarget: () => mapLimbToBreakingTarget,
+	parseStanceWithSide: () => parseStanceWithSide,
+	shouldExecuteSignatureMove: () => shouldExecuteSignatureMove,
+	skillScoreToTier: () => skillScoreToTier
+});
+//#endregion
+export { systems_exports };
+
+//# sourceMappingURL=index.js.map

package/lib/systems/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../src/systems/index.ts"],"sourcesContent":["/**\n * Barrel exports for systems types\n * @module systems\n * @category Game Systems\n */\n\n// Export base types\nexport type {\n  AISystemConfig,\n  AnimationSystemInterface,\n  CombatSystemConfig,\n  CombatSystemInterface,\n  DisplayHitEffect,\n  EffectSystem,\n  EnvironmentalEffect,\n  EventBusInterface,\n  GameSystemManager,\n  GameSystemState,\n  HitEffect,\n  InputSystemInterface,\n  ParticleEffect,\n  PhysicsSystemInterface,\n  RenderingSystemInterface,\n  StatusEffect,\n  SystemConfig,\n  SystemEvent,\n  SystemPerformance,\n  TrigramSystemConfig,\n  TrigramSystemInterface,\n  VisualEffect,\n  VitalPointSystemConfig,\n  VitalPointSystemInterface,\n} from \"./types\";\n\n// Export specific system types\nexport type {\n  CombatEventData,\n  CombatResult,\n  CombatStats,\n  CombatSystem,\n  TrainingCombatResult,\n} from \"./combat\";\n\nexport type {\n  AnatomicalRegion,\n  DamageResult,\n  KoreanTechnique,\n  VitalPoint,\n  VitalPointEffect,\n  VitalPointHitResult,\n  VitalPointSystem,\n} from \"./vitalpoint\";\n\nexport type {\n  StanceTransition,\n  TransitionMetrics,\n  TransitionPath,\n  TrigramCombatStyle,\n  TrigramData,\n  TrigramPhilosophy,\n  TrigramSystem,\n  TrigramTheme,\n  TrigramTransitionCost,\n  TrigramTransitionRule,\n} from \"./trigram\";\n\n// Re-export system types\nexport type {\n  AnimationConfig,\n  AnimationState,\n  CollisionData,\n  PhysicsEntityConfig,\n  PhysicsEntityState,\n  RenderableConfig,\n  Velocity,\n} from \"./types\";\n\nexport * from \"./ai\";\nexport * from \"./combat\";\nexport * from \"./combat/FallIntegration\";\nexport * from \"./CombatSystem\";\nexport * from \"./effects\";\nexport * from \"./game\";\nexport * from \"./LayoutSystem\";\nexport * from \"./player\";\nexport * from \"./trigram\";\nexport * from \"./TrigramSystem\";\nexport * from \"./types\";\nexport * from \"./vitalpoint\";\nexport * from \"./VitalPointSystem\";\n"],"mappings":""}

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

@@ -0,0 +1,275 @@
+/**
+ * Injury-Based Movement Modifier System
+ *
+ * **Korean**: 손상 기반 이동 시스템 (Injury-Based Movement System)
+ *
+ * Dynamically calculates movement speed modifiers based on leg injuries, torso
+ * damage, stance configuration, and pain levels. Part of the 12 combat realism
+ * systems for authentic Korean martial arts gameplay.
+ *
+ * ## Movement Speed Calculation
+ *
+ * Base speed is modified by multiple factors:
+ * - **Leg Injuries**: 0-100% penalty based on health
+ * - **Torso Injuries**: 0-30% minor penalty
+ * - **Both Legs Injured**: Additional 20% cumulative penalty
+ * - **Stance Modifiers**: -20% (defensive) to +25% (offensive)
+ * - **Pain Overload**: -15% when pain ≥ 80
+ *
+ * ## Injury Severity Thresholds
+ *
+ * | Leg Health | State | Speed Penalty |
+ * |-----------|-------|---------------|
+ * | 70-100% | Normal | 0% |
+ * | 30-69% | Limping | 0-40% |
+ * | 10-29% | Severe Limp | 40-80% |
+ * | 0-9% | Critical | 80-100% |
+ *
+ * @module systems/movement/InjuryMovementModifier
+ * @category Movement System
+ * @korean 손상기반이동
+ */
+import type { TrigramStance } from "../../types/common";
+import type { BodyPartHealth } from "../bodypart/types";
+/**
+ * Configuration for injury-based movement calculations.
+ *
+ * **Korean**: 손상 이동 설정
+ *
+ * @public
+ * @category Movement System
+ */
+export interface InjuryMovementConfig {
+    /** Leg health thresholds for injury states */
+    readonly legThresholds: {
+        readonly normal: number;
+        readonly limping: number;
+        readonly critical: number;
+    };
+    /** Maximum torso injury penalty (0.3 = 30%) */
+    readonly maxTorsoPenalty: number;
+    /** Both legs injured cumulative penalty multiplier (0.8 = -20%) */
+    readonly bothLegsInjuredMultiplier: number;
+    /** Pain overload threshold (80) */
+    readonly painOverloadThreshold: number;
+    /** Pain overload penalty multiplier (0.85 = -15%) */
+    readonly painOverloadMultiplier: number;
+    /** Minimum speed multiplier (0.1 = 10% of base speed) */
+    readonly minSpeedMultiplier: number;
+}
+/**
+ * Deep partial type for InjuryMovementConfig to support partial overrides.
+ * Allows callers to override individual threshold values without providing all.
+ *
+ * @public
+ * @category Movement System
+ */
+export type PartialInjuryMovementConfig = {
+    readonly legThresholds?: Partial<InjuryMovementConfig["legThresholds"]>;
+    readonly maxTorsoPenalty?: number;
+    readonly bothLegsInjuredMultiplier?: number;
+    readonly painOverloadThreshold?: number;
+    readonly painOverloadMultiplier?: number;
+    readonly minSpeedMultiplier?: number;
+};
+/**
+ * Default configuration matching acceptance criteria.
+ */
+export declare const DEFAULT_INJURY_MOVEMENT_CONFIG: InjuryMovementConfig;
+/**
+ * Result of injury-based movement calculation.
+ *
+ * **Korean**: 손상 이동 결과
+ *
+ * @public
+ * @category Movement System
+ */
+export interface InjuryMovementResult {
+    /** Final speed in units/second */
+    readonly finalSpeed: number;
+    /** Combined speed multiplier (0.1-1.0+) */
+    readonly speedMultiplier: number;
+    /** Breakdown of penalty sources */
+    readonly penalties: {
+        readonly leftLegPenalty: number;
+        readonly rightLegPenalty: number;
+        readonly torsoPenalty: number;
+        readonly bothLegsInjured: boolean;
+        readonly stanceModifier: number;
+        readonly painOverload: boolean;
+    };
+    /** Whether player is limping */
+    readonly isLimping: boolean;
+    /** Whether player has severe limp */
+    readonly isSevereLimp: boolean;
+    /** Bilingual status text */
+    readonly statusText: {
+        readonly korean: string;
+        readonly english: string;
+    };
+}
+/**
+ * Injury-Based Movement Modifier System.
+ *
+ * **Korean**: 손상 기반 이동 수정자 시스템
+ *
+ * Calculates dynamic movement speed based on injuries, stance, and pain.
+ * Integrates with MovementPhysics to apply realistic combat trauma effects.
+ *
+ * @example
+ * ```typescript
+ * const modifier = new InjuryMovementModifier();
+ *
+ * const result = modifier.calculateMovementSpeed(
+ *   5.0,                    // base speed
+ *   bodyPartHealth,         // current health
+ *   TrigramStance.GEON,     // current stance
+ *   65                      // pain level
+ * );
+ *
+ * console.log(`Speed: ${result.finalSpeed} m/s`);
+ * console.log(`Status: ${result.statusText.korean} | ${result.statusText.english}`);
+ * ```
+ *
+ * @public
+ * @category Movement System
+ * @korean 손상기반이동수정자
+ */
+export declare class InjuryMovementModifier {
+    private readonly config;
+    /**
+     * Threshold for determining if both legs are significantly injured.
+     * Uses epsilon to avoid floating-point rounding issues at boundary.
+     *
+     * @private
+     */
+    private static readonly BOTH_LEGS_THRESHOLD;
+    /**
+     * Creates a new InjuryMovementModifier with optional configuration.
+     *
+     * @param config - Optional configuration overrides (supports partial threshold overrides)
+     */
+    constructor(config?: PartialInjuryMovementConfig);
+    /**
+     * Calculate modified movement speed based on all injury factors.
+     *
+     * **Korean**: 이동 속도 계산
+     *
+     * Applies penalties from:
+     * 1. Leg injuries (primary factor)
+     * 2. Torso injuries (minor factor)
+     * 3. Both legs injured (cumulative penalty)
+     * 4. Stance modifiers
+     * 5. Pain overload
+     *
+     * @param baseSpeed - Base movement speed (m/s)
+     * @param bodyPartHealth - Current body part health values
+     * @param stance - Current trigram stance
+     * @param painLevel - Current pain level (0-100)
+     * @returns Complete movement calculation result
+     *
+     * @public
+     * @korean 이동속도계산
+     */
+    calculateMovementSpeed(baseSpeed: number, bodyPartHealth: BodyPartHealth, stance: TrigramStance, painLevel: number): InjuryMovementResult;
+    /**
+     * Calculate movement penalty from leg injury severity.
+     *
+     * **Korean**: 다리 부상 페널티 계산
+     *
+     * Progressive penalty scaling:
+     * - 100-70%: No penalty (0%)
+     * - 70-30%: Linear scaling (0-40%)
+     * - 30-10%: Accelerated scaling (40-80%)
+     * - 10-0%: Critical scaling (80-100%)
+     *
+     * @param legHealth - Leg health (0-100)
+     * @returns Penalty factor (0.0-1.0), clamped to valid range
+     *
+     * @private
+     */
+    private calculateLegPenalty;
+    /**
+     * Checks if both legs are significantly injured (>30% penalty each).
+     * Uses epsilon-based comparison for floating-point robustness.
+     *
+     * @param leftLegPenalty - Penalty for left leg (0-1)
+     * @param rightLegPenalty - Penalty for right leg (0-1)
+     * @returns True if both legs are significantly injured
+     * @private
+     */
+    private areBothLegsInjured;
+    /**
+     * Get stance-based speed modifier.
+     *
+     * **Korean**: 자세 속도 배수 가져오기
+     *
+     * @param stance - Current trigram stance
+     * @returns Speed multiplier (0.8-1.25), defaults to 1.0 for unknown stances
+     *
+     * @public
+     */
+    getStanceSpeedModifier(stance: TrigramStance): number;
+    /**
+     * Generate bilingual status text based on injury state.
+     *
+     * **Korean**: 상태 텍스트 생성
+     *
+     * @param legHealthForStatus - Leg health percentage used for status determination (typically worst leg)
+     * @param bothLegsInjured - Whether both legs are significantly injured
+     * @param painOverload - Whether pain is over threshold
+     * @returns Bilingual status text
+     *
+     * @private
+     */
+    private generateStatusText;
+    /**
+     * Check if player should display limping animation.
+     *
+     * **Korean**: 절름거림 확인
+     *
+     * Uses worst leg health to match movement penalty behavior.
+     *
+     * @param bodyPartHealth - Current body part health
+     * @returns True if limping animation should play
+     *
+     * @public
+     */
+    shouldLimp(bodyPartHealth: BodyPartHealth): boolean;
+    /**
+     * Check if player has severe limp.
+     *
+     * **Korean**: 중증 절름거림 확인
+     *
+     * Uses worst leg health to match movement penalty behavior.
+     *
+     * @param bodyPartHealth - Current body part health
+     * @returns True if severe limp (leg health < 30%)
+     *
+     * @public
+     */
+    hasSevereLimp(bodyPartHealth: BodyPartHealth): boolean;
+    /**
+     * Get current injury state description.
+     *
+     * **Korean**: 부상 상태 설명
+     *
+     * Uses worst leg health to match movement penalty behavior.
+     *
+     * @param bodyPartHealth - Current body part health
+     * @returns Bilingual injury description
+     *
+     * @public
+     */
+    getInjuryDescription(bodyPartHealth: BodyPartHealth): {
+        korean: string;
+        english: string;
+    };
+}
+/**
+ * Singleton instance for global access.
+ *
+ * @public
+ */
+export declare const injuryMovementModifier: InjuryMovementModifier;
+//# sourceMappingURL=InjuryMovementModifier.d.ts.map

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

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