blacktrigram 0.7.2

package/lib/systems/ai/AdaptiveDifficulty.js

@@ -0,0 +1,297 @@
+//#region src/systems/ai/AdaptiveDifficulty.ts
+/**
+* Difficulty tier levels (5 tiers for adaptive system)
+*/
+var DifficultyTier = /* @__PURE__ */ function(DifficultyTier) {
+	DifficultyTier[DifficultyTier["BEGINNER"] = 1] = "BEGINNER";
+	DifficultyTier[DifficultyTier["NOVICE"] = 2] = "NOVICE";
+	DifficultyTier[DifficultyTier["INTERMEDIATE"] = 3] = "INTERMEDIATE";
+	DifficultyTier[DifficultyTier["ADVANCED"] = 4] = "ADVANCED";
+	DifficultyTier[DifficultyTier["EXPERT"] = 5] = "EXPERT";
+	return DifficultyTier;
+}({});
+/**
+* Difficulty parameter sets for each skill tier
+* Defines AI behavior characteristics at each difficulty level
+* 
+* @korean 각 난이도 단계별 매개변수 설정
+*/
+var DIFFICULTY_PARAMETERS = {
+	[DifficultyTier.BEGINNER]: {
+		reactionTimeMs: {
+			min: 800,
+			max: 1200
+		},
+		vitalPointAccuracy: .4,
+		basicAttackAccuracy: .7,
+		blockTimingWindow: 150,
+		decisionQuality: .5,
+		aggressionModifier: .7,
+		comboChance: .2
+	},
+	[DifficultyTier.NOVICE]: {
+		reactionTimeMs: {
+			min: 500,
+			max: 800
+		},
+		vitalPointAccuracy: .55,
+		basicAttackAccuracy: .78,
+		blockTimingWindow: 120,
+		decisionQuality: .65,
+		aggressionModifier: .9,
+		comboChance: .35
+	},
+	[DifficultyTier.INTERMEDIATE]: {
+		reactionTimeMs: {
+			min: 300,
+			max: 500
+		},
+		vitalPointAccuracy: .65,
+		basicAttackAccuracy: .85,
+		blockTimingWindow: 90,
+		decisionQuality: .75,
+		aggressionModifier: 1.1,
+		comboChance: .5
+	},
+	[DifficultyTier.ADVANCED]: {
+		reactionTimeMs: {
+			min: 150,
+			max: 300
+		},
+		vitalPointAccuracy: .75,
+		basicAttackAccuracy: .9,
+		blockTimingWindow: 70,
+		decisionQuality: .85,
+		aggressionModifier: 1.3,
+		comboChance: .6
+	},
+	[DifficultyTier.EXPERT]: {
+		reactionTimeMs: {
+			min: 50,
+			max: 150
+		},
+		vitalPointAccuracy: .85,
+		basicAttackAccuracy: .95,
+		blockTimingWindow: 50,
+		decisionQuality: .95,
+		aggressionModifier: 1.5,
+		comboChance: .7
+	}
+};
+/**
+* Map skill score (0.0-1.0) to difficulty tier
+* Uses fixed thresholds for consistent tier assignment
+* 
+* @korean 실력 점수를 난이도 단계로 변환
+* 
+* @param score - Player skill score (0.0-1.0)
+* @returns Corresponding difficulty tier
+*/
+function skillScoreToTier(score) {
+	if (score < .2) return DifficultyTier.BEGINNER;
+	if (score < .4) return DifficultyTier.NOVICE;
+	if (score < .6) return DifficultyTier.INTERMEDIATE;
+	if (score < .8) return DifficultyTier.ADVANCED;
+	return DifficultyTier.EXPERT;
+}
+/**
+* Linear interpolation helper
+* @param a - Start value
+* @param b - End value
+* @param t - Interpolation factor (0.0-1.0)
+* @returns Interpolated value
+*/
+function lerp(a, b, t) {
+	return a + (b - a) * Math.max(0, Math.min(1, t));
+}
+/**
+* Interpolate between two difficulty parameter sets
+* Used for smooth difficulty transitions over time
+* 
+* @korean 난이도 매개변수 간 부드러운 전환
+* 
+* @param from - Starting difficulty parameters
+* @param to - Target difficulty parameters
+* @param progress - Interpolation progress (0.0-1.0)
+* @returns Interpolated difficulty parameters
+*/
+function interpolateDifficultyParameters(from, to, progress) {
+	const t = Math.max(0, Math.min(1, progress));
+	return {
+		reactionTimeMs: {
+			min: lerp(from.reactionTimeMs.min, to.reactionTimeMs.min, t),
+			max: lerp(from.reactionTimeMs.max, to.reactionTimeMs.max, t)
+		},
+		vitalPointAccuracy: lerp(from.vitalPointAccuracy, to.vitalPointAccuracy, t),
+		basicAttackAccuracy: lerp(from.basicAttackAccuracy, to.basicAttackAccuracy, t),
+		blockTimingWindow: lerp(from.blockTimingWindow, to.blockTimingWindow, t),
+		decisionQuality: lerp(from.decisionQuality, to.decisionQuality, t),
+		aggressionModifier: lerp(from.aggressionModifier, to.aggressionModifier, t),
+		comboChance: lerp(from.comboChance, to.comboChance, t)
+	};
+}
+/**
+* Adaptive Difficulty System
+*/
+var AdaptiveDifficulty = class {
+	playerSkillMetrics;
+	skillDecay = .95;
+	learningRate = .1;
+	constructor() {
+		this.playerSkillMetrics = {
+			averageAccuracy: .5,
+			comboCount: 0,
+			perfectBlocks: 0,
+			reactionTime: 800,
+			vitalPointHits: 0,
+			stanceTransitions: 0,
+			damageEfficiency: .5,
+			matchesPlayed: 0
+		};
+	}
+	/**
+	* Update player skill metrics based on match performance
+	*/
+	updateSkillMetrics(matchData) {
+		const { metrics } = this;
+		const matchAccuracy = matchData.totalAttacks > 0 ? matchData.hitsLanded / matchData.totalAttacks : .5;
+		metrics.averageAccuracy = metrics.averageAccuracy * (1 - this.learningRate) + matchAccuracy * this.learningRate;
+		metrics.comboCount += matchData.combosExecuted;
+		metrics.perfectBlocks += matchData.perfectBlockCount;
+		if (matchData.avgReactionTimeMs > 0) metrics.reactionTime = metrics.reactionTime * (1 - this.learningRate) + matchData.avgReactionTimeMs * this.learningRate;
+		metrics.vitalPointHits += matchData.vitalPointsHit;
+		metrics.stanceTransitions += matchData.effectiveStanceChanges;
+		const matchEfficiency = matchData.damageTaken > 0 ? Math.min(1, matchData.damageDealt / matchData.damageTaken) : matchData.damageDealt > 0 ? 1 : .5;
+		metrics.damageEfficiency = metrics.damageEfficiency * (1 - this.learningRate) + matchEfficiency * this.learningRate;
+		metrics.matchesPlayed += 1;
+		this.applySkillDecay();
+	}
+	/**
+	* Apply gradual skill decay to prevent over-adjustment
+	*/
+	applySkillDecay() {
+		const { metrics } = this;
+		metrics.averageAccuracy = metrics.averageAccuracy * this.skillDecay + .5 * (1 - this.skillDecay);
+		metrics.damageEfficiency = metrics.damageEfficiency * this.skillDecay + .5 * (1 - this.skillDecay);
+	}
+	/**
+	* Calculate overall player skill level (0.0 - 1.0)
+	*/
+	calculatePlayerSkill() {
+		const { metrics } = this;
+		const accuracyScore = metrics.averageAccuracy * .3;
+		const comboScore = Math.min(1, metrics.comboCount / 20) * .2;
+		const blockScore = Math.min(1, metrics.perfectBlocks / 10) * .2;
+		const reactionScore = Math.max(0, 1 - metrics.reactionTime / 1e3) * .15;
+		const vitalScore = Math.min(1, metrics.vitalPointHits / 15) * .15;
+		return accuracyScore + comboScore + blockScore + reactionScore + vitalScore;
+	}
+	/**
+	* Get current difficulty tier based on skill level
+	*/
+	getDifficultyTier() {
+		return skillScoreToTier(this.calculatePlayerSkill());
+	}
+	/**
+	* Get difficulty parameters for current skill tier
+	* Returns the appropriate DifficultyParameters based on player skill
+	* 
+	* @korean 현재 실력 단계에 맞는 난이도 매개변수 반환
+	*/
+	getDifficultyParameters() {
+		return DIFFICULTY_PARAMETERS[this.getDifficultyTier()];
+	}
+	/**
+	* Adjust AI personality based on player skill
+	*/
+	adjustAIPersonality(personality) {
+		const skillLevel = this.calculatePlayerSkill();
+		const tier = this.getDifficultyTier();
+		const aggressionScale = 1 + tier * .1;
+		const feintScale = 1 + tier * .15;
+		const comboScale = 1 + tier * .12;
+		const stanceScale = 1 + tier * .08;
+		return {
+			...personality,
+			aggressionLevel: Math.min(.95, personality.aggressionLevel * aggressionScale),
+			feintChance: Math.min(.6, personality.feintChance * feintScale),
+			comboTendency: Math.min(.85, personality.comboTendency * comboScale),
+			stanceSwitchFrequency: Math.min(.9, personality.stanceSwitchFrequency * stanceScale),
+			tacticalRetreatThreshold: Math.max(.1, personality.tacticalRetreatThreshold * (1 - skillLevel * .3))
+		};
+	}
+	/**
+	* Get skill metrics
+	*/
+	getMetrics() {
+		return { ...this.playerSkillMetrics };
+	}
+	/**
+	* Reset skill metrics
+	*/
+	reset() {
+		this.playerSkillMetrics = {
+			averageAccuracy: .5,
+			comboCount: 0,
+			perfectBlocks: 0,
+			reactionTime: 800,
+			vitalPointHits: 0,
+			stanceTransitions: 0,
+			damageEfficiency: .5,
+			matchesPlayed: 0
+		};
+	}
+	/**
+	* Get difficulty adjustment recommendation
+	*/
+	getDifficultyRecommendation() {
+		const skillLevel = this.calculatePlayerSkill();
+		const tier = this.getDifficultyTier();
+		const shouldIncrease = skillLevel > .7 && tier < DifficultyTier.EXPERT;
+		const tierNames = {
+			[DifficultyTier.BEGINNER]: "Beginner (초보)",
+			[DifficultyTier.NOVICE]: "Novice (입문)",
+			[DifficultyTier.INTERMEDIATE]: "Intermediate (중급)",
+			[DifficultyTier.ADVANCED]: "Advanced (고급)",
+			[DifficultyTier.EXPERT]: "Expert (전문)"
+		};
+		let message;
+		if (shouldIncrease) message = "Player shows mastery - increasing difficulty";
+		else if (skillLevel < .3) message = "Player struggling - maintaining current difficulty";
+		else message = "Player performing well - difficulty appropriate";
+		return {
+			tier,
+			tierName: tierNames[tier],
+			skillLevel,
+			shouldIncrease,
+			message
+		};
+	}
+	/**
+	* Export metrics for persistence
+	*/
+	exportMetrics() {
+		return JSON.stringify(this.playerSkillMetrics);
+	}
+	/**
+	* Import metrics from persistence
+	*/
+	importMetrics(data) {
+		try {
+			this.playerSkillMetrics = JSON.parse(data);
+			return true;
+		} catch {
+			return false;
+		}
+	}
+	/**
+	* Get reference to metrics (for internal use)
+	*/
+	get metrics() {
+		return this.playerSkillMetrics;
+	}
+};
+//#endregion
+export { AdaptiveDifficulty, DIFFICULTY_PARAMETERS, DifficultyTier, interpolateDifficultyParameters, skillScoreToTier };
+
+//# sourceMappingURL=AdaptiveDifficulty.js.map

package/lib/systems/ai/AdaptiveDifficulty.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AdaptiveDifficulty.js","names":[],"sources":["../../../src/systems/ai/AdaptiveDifficulty.ts"],"sourcesContent":["/**\n * Adaptive Difficulty System for Korean Martial Arts Combat\n * Tracks player skill metrics and adjusts AI difficulty dynamically\n */\n\nimport { AIPersonality } from \"./AIPersonality\";\n\n/**\n * Player skill metrics tracked for adaptive difficulty\n */\nexport interface PlayerSkillMetrics {\n  averageAccuracy: number; // 0.0-1.0: Hit rate\n  comboCount: number; // Total combos executed\n  perfectBlocks: number; // Perfect timing blocks\n  reactionTime: number; // Average reaction time in ms\n  vitalPointHits: number; // Successful vital point strikes\n  stanceTransitions: number; // Effective stance changes\n  damageEfficiency: number; // 0.0-1.0: Damage dealt vs taken ratio\n  matchesPlayed: number; // Total matches for scaling\n}\n\n/**\n * Difficulty tier levels (5 tiers for adaptive system)\n */\nexport enum DifficultyTier {\n  BEGINNER = 1,\n  NOVICE = 2,\n  INTERMEDIATE = 3,\n  ADVANCED = 4,\n  EXPERT = 5,\n}\n\n/**\n * Difficulty parameters that control AI behavior\n * Applied dynamically based on player skill level\n * \n * @korean 난이도 매개변수 - 플레이어 실력에 따라 AI 행동 제어\n */\nexport interface DifficultyParameters {\n  /** AI reaction time range in milliseconds */\n  readonly reactionTimeMs: { readonly min: number; readonly max: number };\n  /** Accuracy for vital point strikes (0.0-1.0) */\n  readonly vitalPointAccuracy: number;\n  /** Accuracy for basic attacks (0.0-1.0) */\n  readonly basicAttackAccuracy: number;\n  /** Block timing window in milliseconds (smaller = harder to block) */\n  readonly blockTimingWindow: number;\n  /** Decision quality affects technique selection optimality (0.0-1.0) */\n  readonly decisionQuality: number;\n  /** Aggression modifier multiplier (0.5-2.0) */\n  readonly aggressionModifier: number;\n  /** Chance to attempt combo sequences (0.0-1.0) */\n  readonly comboChance: number;\n}\n\n/**\n * Difficulty parameter sets for each skill tier\n * Defines AI behavior characteristics at each difficulty level\n * \n * @korean 각 난이도 단계별 매개변수 설정\n */\nexport const DIFFICULTY_PARAMETERS: Record<DifficultyTier, DifficultyParameters> = {\n  [DifficultyTier.BEGINNER]: {\n    reactionTimeMs: { min: 800, max: 1200 },\n    vitalPointAccuracy: 0.40,\n    basicAttackAccuracy: 0.70,\n    blockTimingWindow: 150,\n    decisionQuality: 0.50,\n    aggressionModifier: 0.7,\n    comboChance: 0.20,\n  },\n  [DifficultyTier.NOVICE]: {\n    reactionTimeMs: { min: 500, max: 800 },\n    vitalPointAccuracy: 0.55,\n    basicAttackAccuracy: 0.78,\n    blockTimingWindow: 120,\n    decisionQuality: 0.65,\n    aggressionModifier: 0.9,\n    comboChance: 0.35,\n  },\n  [DifficultyTier.INTERMEDIATE]: {\n    reactionTimeMs: { min: 300, max: 500 },\n    vitalPointAccuracy: 0.65,\n    basicAttackAccuracy: 0.85,\n    blockTimingWindow: 90,\n    decisionQuality: 0.75,\n    aggressionModifier: 1.1,\n    comboChance: 0.50,\n  },\n  [DifficultyTier.ADVANCED]: {\n    reactionTimeMs: { min: 150, max: 300 },\n    vitalPointAccuracy: 0.75,\n    basicAttackAccuracy: 0.90,\n    blockTimingWindow: 70,\n    decisionQuality: 0.85,\n    aggressionModifier: 1.3,\n    comboChance: 0.60,\n  },\n  [DifficultyTier.EXPERT]: {\n    reactionTimeMs: { min: 50, max: 150 },\n    vitalPointAccuracy: 0.85,\n    basicAttackAccuracy: 0.95,\n    blockTimingWindow: 50,\n    decisionQuality: 0.95,\n    aggressionModifier: 1.5,\n    comboChance: 0.70,\n  },\n};\n\n/**\n * Map skill score (0.0-1.0) to difficulty tier\n * Uses fixed thresholds for consistent tier assignment\n * \n * @korean 실력 점수를 난이도 단계로 변환\n * \n * @param score - Player skill score (0.0-1.0)\n * @returns Corresponding difficulty tier\n */\nexport function skillScoreToTier(score: number): DifficultyTier {\n  if (score < 0.2) return DifficultyTier.BEGINNER;\n  if (score < 0.4) return DifficultyTier.NOVICE;\n  if (score < 0.6) return DifficultyTier.INTERMEDIATE;\n  if (score < 0.8) return DifficultyTier.ADVANCED;\n  return DifficultyTier.EXPERT;\n}\n\n/**\n * Linear interpolation helper\n * @param a - Start value\n * @param b - End value\n * @param t - Interpolation factor (0.0-1.0)\n * @returns Interpolated value\n */\nfunction lerp(a: number, b: number, t: number): number {\n  return a + (b - a) * Math.max(0, Math.min(1, t));\n}\n\n/**\n * Interpolate between two difficulty parameter sets\n * Used for smooth difficulty transitions over time\n * \n * @korean 난이도 매개변수 간 부드러운 전환\n * \n * @param from - Starting difficulty parameters\n * @param to - Target difficulty parameters\n * @param progress - Interpolation progress (0.0-1.0)\n * @returns Interpolated difficulty parameters\n */\nexport function interpolateDifficultyParameters(\n  from: DifficultyParameters,\n  to: DifficultyParameters,\n  progress: number\n): DifficultyParameters {\n  const t = Math.max(0, Math.min(1, progress));\n  \n  return {\n    reactionTimeMs: {\n      min: lerp(from.reactionTimeMs.min, to.reactionTimeMs.min, t),\n      max: lerp(from.reactionTimeMs.max, to.reactionTimeMs.max, t),\n    },\n    vitalPointAccuracy: lerp(from.vitalPointAccuracy, to.vitalPointAccuracy, t),\n    basicAttackAccuracy: lerp(from.basicAttackAccuracy, to.basicAttackAccuracy, t),\n    blockTimingWindow: lerp(from.blockTimingWindow, to.blockTimingWindow, t),\n    decisionQuality: lerp(from.decisionQuality, to.decisionQuality, t),\n    aggressionModifier: lerp(from.aggressionModifier, to.aggressionModifier, t),\n    comboChance: lerp(from.comboChance, to.comboChance, t),\n  };\n}\n\n/**\n * Adaptive Difficulty System\n */\nexport class AdaptiveDifficulty {\n  private playerSkillMetrics: PlayerSkillMetrics;\n  private readonly skillDecay = 0.95; // Gradual skill decay between matches\n  private readonly learningRate = 0.1; // How quickly to adapt\n\n  constructor() {\n    this.playerSkillMetrics = {\n      averageAccuracy: 0.5,\n      comboCount: 0,\n      perfectBlocks: 0,\n      reactionTime: 800,\n      vitalPointHits: 0,\n      stanceTransitions: 0,\n      damageEfficiency: 0.5,\n      matchesPlayed: 0,\n    };\n  }\n\n  /**\n   * Update player skill metrics based on match performance\n   */\n  updateSkillMetrics(matchData: {\n    hitsLanded: number;\n    totalAttacks: number;\n    combosExecuted: number;\n    perfectBlockCount: number;\n    avgReactionTimeMs: number;\n    vitalPointsHit: number;\n    effectiveStanceChanges: number;\n    damageDealt: number;\n    damageTaken: number;\n  }): void {\n    const { metrics } = this;\n\n    // Update accuracy with learning rate\n    const matchAccuracy =\n      matchData.totalAttacks > 0\n        ? matchData.hitsLanded / matchData.totalAttacks\n        : 0.5;\n    metrics.averageAccuracy =\n      metrics.averageAccuracy * (1 - this.learningRate) +\n      matchAccuracy * this.learningRate;\n\n    // Update combo count\n    metrics.comboCount += matchData.combosExecuted;\n\n    // Update perfect blocks\n    metrics.perfectBlocks += matchData.perfectBlockCount;\n\n    // Update reaction time\n    if (matchData.avgReactionTimeMs > 0) {\n      metrics.reactionTime =\n        metrics.reactionTime * (1 - this.learningRate) +\n        matchData.avgReactionTimeMs * this.learningRate;\n    }\n\n    // Update vital point hits\n    metrics.vitalPointHits += matchData.vitalPointsHit;\n\n    // Update stance transitions\n    metrics.stanceTransitions += matchData.effectiveStanceChanges;\n\n    // Update damage efficiency\n    const matchEfficiency =\n      matchData.damageTaken > 0\n        ? Math.min(1, matchData.damageDealt / matchData.damageTaken)\n        : matchData.damageDealt > 0\n        ? 1.0 // Perfect defense with damage dealt\n        : 0.5; // No damage on either side\n    metrics.damageEfficiency =\n      metrics.damageEfficiency * (1 - this.learningRate) +\n      matchEfficiency * this.learningRate;\n\n    // Increment matches played\n    metrics.matchesPlayed += 1;\n\n    // Apply skill decay to prevent over-adjustment\n    this.applySkillDecay();\n  }\n\n  /**\n   * Apply gradual skill decay to prevent over-adjustment\n   */\n  private applySkillDecay(): void {\n    const { metrics } = this;\n    metrics.averageAccuracy =\n      metrics.averageAccuracy * this.skillDecay +\n      0.5 * (1 - this.skillDecay);\n    metrics.damageEfficiency =\n      metrics.damageEfficiency * this.skillDecay +\n      0.5 * (1 - this.skillDecay);\n  }\n\n  /**\n   * Calculate overall player skill level (0.0 - 1.0)\n   */\n  calculatePlayerSkill(): number {\n    const { metrics } = this;\n\n    // Weight different skill components\n    const accuracyScore = metrics.averageAccuracy * 0.3;\n    const comboScore = Math.min(1, metrics.comboCount / 20) * 0.2;\n    const blockScore = Math.min(1, metrics.perfectBlocks / 10) * 0.2;\n    const reactionScore = Math.max(0, 1 - metrics.reactionTime / 1000) * 0.15;\n    const vitalScore = Math.min(1, metrics.vitalPointHits / 15) * 0.15;\n\n    return accuracyScore + comboScore + blockScore + reactionScore + vitalScore;\n  }\n\n  /**\n   * Get current difficulty tier based on skill level\n   */\n  getDifficultyTier(): DifficultyTier {\n    const skillLevel = this.calculatePlayerSkill();\n    return skillScoreToTier(skillLevel);\n  }\n\n  /**\n   * Get difficulty parameters for current skill tier\n   * Returns the appropriate DifficultyParameters based on player skill\n   * \n   * @korean 현재 실력 단계에 맞는 난이도 매개변수 반환\n   */\n  getDifficultyParameters(): DifficultyParameters {\n    const tier = this.getDifficultyTier();\n    return DIFFICULTY_PARAMETERS[tier];\n  }\n\n  /**\n   * Adjust AI personality based on player skill\n   */\n  adjustAIPersonality(personality: AIPersonality): AIPersonality {\n    const skillLevel = this.calculatePlayerSkill();\n    const tier = this.getDifficultyTier();\n\n    // Scale factors based on difficulty tier\n    const aggressionScale = 1 + tier * 0.1; // +10% per tier\n    const feintScale = 1 + tier * 0.15; // +15% per tier\n    const comboScale = 1 + tier * 0.12; // +12% per tier\n    const stanceScale = 1 + tier * 0.08; // +8% per tier\n\n    return {\n      ...personality,\n      aggressionLevel: Math.min(\n        0.95,\n        personality.aggressionLevel * aggressionScale\n      ),\n      feintChance: Math.min(0.6, personality.feintChance * feintScale),\n      comboTendency: Math.min(0.85, personality.comboTendency * comboScale),\n      stanceSwitchFrequency: Math.min(\n        0.9,\n        personality.stanceSwitchFrequency * stanceScale\n      ),\n      // Adjust retreat threshold - better players face more aggressive AI\n      tacticalRetreatThreshold: Math.max(\n        0.1,\n        personality.tacticalRetreatThreshold * (1 - skillLevel * 0.3)\n      ),\n    };\n  }\n\n  /**\n   * Get skill metrics\n   */\n  getMetrics(): Readonly<PlayerSkillMetrics> {\n    return { ...this.playerSkillMetrics };\n  }\n\n  /**\n   * Reset skill metrics\n   */\n  reset(): void {\n    this.playerSkillMetrics = {\n      averageAccuracy: 0.5,\n      comboCount: 0,\n      perfectBlocks: 0,\n      reactionTime: 800,\n      vitalPointHits: 0,\n      stanceTransitions: 0,\n      damageEfficiency: 0.5,\n      matchesPlayed: 0,\n    };\n  }\n\n  /**\n   * Get difficulty adjustment recommendation\n   */\n  getDifficultyRecommendation(): {\n    tier: DifficultyTier;\n    tierName: string;\n    skillLevel: number;\n    shouldIncrease: boolean;\n    message: string;\n  } {\n    const skillLevel = this.calculatePlayerSkill();\n    const tier = this.getDifficultyTier();\n    const shouldIncrease = skillLevel > 0.7 && tier < DifficultyTier.EXPERT;\n\n    const tierNames: Record<DifficultyTier, string> = {\n      [DifficultyTier.BEGINNER]: \"Beginner (초보)\",\n      [DifficultyTier.NOVICE]: \"Novice (입문)\",\n      [DifficultyTier.INTERMEDIATE]: \"Intermediate (중급)\",\n      [DifficultyTier.ADVANCED]: \"Advanced (고급)\",\n      [DifficultyTier.EXPERT]: \"Expert (전문)\",\n    };\n\n    let message: string;\n    if (shouldIncrease) {\n      message = \"Player shows mastery - increasing difficulty\";\n    } else if (skillLevel < 0.3) {\n      message = \"Player struggling - maintaining current difficulty\";\n    } else {\n      message = \"Player performing well - difficulty appropriate\";\n    }\n\n    return {\n      tier,\n      tierName: tierNames[tier],\n      skillLevel,\n      shouldIncrease,\n      message,\n    };\n  }\n\n  /**\n   * Export metrics for persistence\n   */\n  exportMetrics(): string {\n    return JSON.stringify(this.playerSkillMetrics);\n  }\n\n  /**\n   * Import metrics from persistence\n   */\n  importMetrics(data: string): boolean {\n    try {\n      const metrics = JSON.parse(data) as PlayerSkillMetrics;\n      this.playerSkillMetrics = metrics;\n      return true;\n    } catch {\n      return false;\n    }\n  }\n\n  /**\n   * Get reference to metrics (for internal use)\n   */\n  private get metrics(): PlayerSkillMetrics {\n    return this.playerSkillMetrics;\n  }\n}\n"],"mappings":"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"}

package/lib/systems/ai/ArchetypeEnforcer.d.ts

@@ -0,0 +1,132 @@
+/**
+ * Archetype Behavior Enforcement System
+ *
+ * Centralizes archetype-specific combat philosophy enforcement to ensure
+ * each of the 5 player archetypes has immediately recognizable and distinct
+ * AI behavior patterns.
+ *
+ * **Korean Philosophy Integration (한국 무술 철학)**:
+ * - 무사 (Musa): 명예 (Honor) - Direct, honorable combat
+ * - 암살자 (Amsalja): 은밀 (Stealth) - Silent, precise takedowns
+ * - 해커 (Hacker): 분석 (Analysis) - Tech-enhanced tactical combat
+ * - 정보요원 (Jeongbo): 심리전 (Psychological Warfare) - Strategic manipulation
+ * - 조직폭력배 (Jojik): 생존 (Survival) - Ruthless, unpredictable tactics
+ *
+ * @module systems/ai/ArchetypeEnforcer
+ * @category AI Combat
+ * @korean 원형 행동 강화 시스템
+ */
+import { PlayerArchetype } from "../../types";
+import { AIDecision, AIActionType, CombatContext } from "./types";
+/**
+ * Archetype enforcement rules defining distinct combat behaviors
+ *
+ * Each archetype has:
+ * - Preferred actions (used most frequently)
+ * - Prohibited actions (never used due to philosophy)
+ * - Signature move (iconic technique with specific trigger condition)
+ * - Action frequencies (target distribution percentages)
+ *
+ * **Note on Action Frequencies**:
+ * These values represent **target frequencies/proportions** for each action type
+ * rather than a single normalized probability distribution. Multiple actions can have
+ * high target frequencies because they can occur in overlapping situations:
+ * - ATTACK (70%) and TECHNIQUE (70%) both represent aggressive behavior
+ * - STANCE_CHANGE (80%) occurs frequently but doesn't prevent other actions
+ * - The frequencies serve as **behavioral targets** to guide AI personality,
+ *   and are not required to sum to 100% across all actions
+ *
+ * @korean 원형 강화 규칙
+ */
+export interface ArchetypeEnforcementRules {
+    /** Actions this archetype uses most frequently */
+    readonly preferredActions: readonly AIActionType[];
+    /** Actions this archetype never uses (philosophy conflicts) */
+    readonly prohibitedActions: readonly AIActionType[];
+    /** Signature technique ID for this archetype */
+    readonly signatureMove: string;
+    /** Condition function to trigger signature move */
+    readonly signatureCondition: (context: CombatContext) => boolean;
+    /** Target frequency distribution for each action type (0.0-1.0) */
+    readonly actionFrequencies: Readonly<Record<AIActionType, number>>;
+}
+/**
+ * Archetype enforcement rules for all 5 player archetypes
+ *
+ * Defines distinct combat philosophies with measurable behavior patterns
+ * that make each archetype immediately identifiable through AI actions.
+ *
+ * @korean 5대 원형 강화 규칙
+ */
+export declare const ARCHETYPE_ENFORCEMENT: Record<PlayerArchetype, ArchetypeEnforcementRules>;
+/**
+ * Enforce archetype-specific behavior on AI decision
+ *
+ * Applies philosophy-based restrictions and redirects to enforce distinct
+ * combat patterns for each archetype. This ensures players can identify
+ * which archetype they're fighting based on behavior alone.
+ *
+ * **Enforcement Logic**:
+ * 1. Check for prohibited actions → Replace with preferred action
+ * 2. Check for signature move condition → Override with signature move
+ * 3. Return decision (possibly modified)
+ *
+ * @korean 원형 행동 강화
+ *
+ * @param decision - Original AI decision from DecisionTree
+ * @param archetype - Player archetype to enforce
+ * @param context - Current combat context
+ * @returns Modified decision enforcing archetype philosophy
+ */
+export declare function enforceArchetypeBehavior(decision: AIDecision, archetype: PlayerArchetype, context: CombatContext): AIDecision;
+/**
+ * Get signature move ID for archetype
+ *
+ * Returns the technique ID of this archetype's signature move.
+ * Used for technique selection in useAICombat.ts.
+ *
+ * @korean 서명 기술 ID 가져오기
+ *
+ * @param archetype - Player archetype
+ * @returns Signature technique ID
+ */
+export declare function getSignatureMove(archetype: PlayerArchetype): string;
+/**
+ * Check if signature move condition is met
+ *
+ * Evaluates whether the archetype should execute its signature move
+ * based on current combat context.
+ *
+ * @korean 서명 기술 조건 확인
+ *
+ * @param archetype - Player archetype
+ * @param context - Current combat context
+ * @returns True if signature move should be executed
+ */
+export declare function shouldExecuteSignatureMove(archetype: PlayerArchetype, context: CombatContext): boolean;
+/**
+ * Get action frequency target for archetype
+ *
+ * Returns the target frequency (0.0-1.0) for a specific action type
+ * based on archetype combat philosophy.
+ *
+ * @korean 행동 빈도 목표 가져오기
+ *
+ * @param archetype - Player archetype
+ * @param actionType - AI action type
+ * @returns Target frequency for this action (0.0-1.0)
+ */
+export declare function getActionFrequency(archetype: PlayerArchetype, actionType: AIActionType): number;
+/**
+ * Check if action is prohibited for archetype
+ *
+ * Returns true if the archetype's philosophy prohibits using this action.
+ *
+ * @korean 금지된 행동 확인
+ *
+ * @param archetype - Player archetype
+ * @param actionType - AI action type to check
+ * @returns True if action is prohibited
+ */
+export declare function isActionProhibited(archetype: PlayerArchetype, actionType: AIActionType): boolean;
+//# sourceMappingURL=ArchetypeEnforcer.d.ts.map

package/lib/systems/ai/ArchetypeEnforcer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ArchetypeEnforcer.d.ts","sourceRoot":"","sources":["../../../src/systems/ai/ArchetypeEnforcer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAC1C,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAElE;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,WAAW,yBAAyB;IACxC,kDAAkD;IAClD,QAAQ,CAAC,gBAAgB,EAAE,SAAS,YAAY,EAAE,CAAC;IAEnD,+DAA+D;IAC/D,QAAQ,CAAC,iBAAiB,EAAE,SAAS,YAAY,EAAE,CAAC;IAEpD,gDAAgD;IAChD,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAE/B,mDAAmD;IACnD,QAAQ,CAAC,kBAAkB,EAAE,CAAC,OAAO,EAAE,aAAa,KAAK,OAAO,CAAC;IAEjE,mEAAmE;IACnE,QAAQ,CAAC,iBAAiB,EAAE,QAAQ,CAAC,MAAM,CAAC,YAAY,EAAE,MAAM,CAAC,CAAC,CAAC;CACpE;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,qBAAqB,EAAE,MAAM,CAAC,eAAe,EAAE,yBAAyB,CA0KpF,CAAC;AAEF;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,wBAAwB,CACtC,QAAQ,EAAE,UAAU,EACpB,SAAS,EAAE,eAAe,EAC1B,OAAO,EAAE,aAAa,GACrB,UAAU,CAyCZ;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,eAAe,GAAG,MAAM,CAEnE;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,0BAA0B,CACxC,SAAS,EAAE,eAAe,EAC1B,OAAO,EAAE,aAAa,GACrB,OAAO,CAGT;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,kBAAkB,CAChC,SAAS,EAAE,eAAe,EAC1B,UAAU,EAAE,YAAY,GACvB,MAAM,CAER;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAChC,SAAS,EAAE,eAAe,EAC1B,UAAU,EAAE,YAAY,GACvB,OAAO,CAET"}