playlist-data-engine 1.1.0

package/dist/core/generation/EnemyGenerator.d.ts

@@ -0,0 +1,595 @@
+/**
+ * EnemyGenerator - Generates enemy characters from templates
+ *
+ * Provides deterministic enemy generation based on:
+ * - Enemy templates (base stats, signature abilities)
+ * - Rarity tiers (stat scaling, ability scaling)
+ * - Audio profiles (template selection influence)
+ *
+ * All generation is seeded for reproducibility.
+ */
+import type { CharacterSheet } from '../types/Character.js';
+import type { EnemyTemplate, EnemyGenerationOptions, EncounterGenerationOptions } from '../types/Enemy.js';
+/**
+ * EnemyGenerator - Static class for enemy generation
+ *
+ * Generates enemy CharacterSheet instances from templates with:
+ * - Deterministic seeded randomness
+ * - Rarity-based stat scaling
+ * - Signature ability dice scaling
+ * - Audio-influenced template selection
+ *
+ * @example
+ * ```typescript
+ * // Generate a specific elite orc
+ * const orc = EnemyGenerator.generate({
+ *   seed: 'my-encounter',
+ *   templateId: 'orc',
+ *   rarity: 'elite'
+ * });
+ *
+ * // Generate a random humanoid brute
+ * const enemy = EnemyGenerator.generate({
+ *   seed: 'random-1',
+ *   category: 'humanoid',
+ *   archetype: 'brute',
+ *   rarity: 'common'
+ * });
+ * ```
+ */
+export declare class EnemyGenerator {
+    /**
+     * Archetype tag mappings for feature selection
+     *
+     * Maps each enemy archetype to feature tags that are appropriate
+     * for selecting extra abilities from FeatureQuery.
+     *
+     * Brutes benefit from durability and melee damage abilities
+     * Archers benefit from accuracy and mobility abilities
+     * Support enemies benefit from healing and buff abilities
+     */
+    private static readonly ARCHETYPE_TAGS;
+    /**
+     * Maximum stat increase from audio influence
+     *
+     * This prevents extreme stat values from audio profiles.
+     * Audio influence is additive to rarity scaling, not multiplicative.
+     */
+    private static readonly MAX_AUDIO_INFLUENCE;
+    /**
+     * Get a seeded RNG instance with optional index offset
+     *
+     * Creates a deterministic RNG from seed. When index is provided,
+     * appends it to the seed for unique sequences per enemy.
+     *
+     * @param seed - Base seed string
+     * @param index - Optional index for unique sequences
+     * @returns Seeded RNG instance
+     */
+    private static getSeededRNG;
+    /**
+     * Apply audio influence to ability scores
+     *
+     * Applies subtle stat adjustments based on audio profile characteristics.
+     * This is additive to rarity scaling, providing flavor rather than major power shifts.
+     *
+     * Frequency band → stat mapping:
+     * - Bass dominance → +1 to STR and CON
+     * - Treble dominance → +1 to DEX
+     * - Mid dominance → +1 to WIS and CHA
+     * - Balanced → +1 to all (smaller bonus)
+     *
+     * Maximum total increase from audio influence is capped at +2 per stat
+     * to prevent extreme values.
+     *
+     * @param stats - Base ability scores to modify
+     * @param audioProfile - Audio profile for influence calculation
+     * @returns Modified ability scores with audio influence applied
+     *
+     * @example
+     * ```typescript
+     * const stats = { STR: 16, DEX: 12, CON: 14, INT: 10, WIS: 8, CHA: 8 };
+     * const audioProfile = { bass_dominance: 0.8, mid_dominance: 0.1, treble_dominance: 0.1 };
+     * const modified = applyAudioStatInfluence(stats, audioProfile);
+     * // Returns: { STR: 17, DEX: 12, CON: 15, INT: 10, WIS: 8, CHA: 8 } (bass → STR, CON)
+     * ```
+     */
+    private static applyAudioStatInfluence;
+    /**
+     * Scale ability scores based on rarity tier and optional CR
+     *
+     * Applies the rarity multiplier to each ability score.
+     * If CR is provided, also applies fractional CR reduction for sub-level enemies.
+     * Results are rounded to nearest integer.
+     *
+     * The multipliers are applied in order:
+     * 1. Fractional CR multiplier (if CR < 1) - reduces stats for sub-level enemies
+     * 2. Rarity multiplier - minor complexity-based stat adjustment (max 12%)
+     *
+     * DESIGN PRINCIPLE: Rarity affects complexity, CR affects power.
+     * The rarity statMultiplier is intentionally small (1.0-1.12) to avoid
+     * overpowering enemies. CR handles the primary power scaling.
+     *
+     * @param baseStats - Base ability scores from template
+     * @param rarity - Rarity tier for scaling
+     * @param cr - Optional Challenge Rating for fractional CR stat reduction
+     * @returns Scaled ability scores
+     *
+     * @example
+     * ```typescript
+     * // Rarity only (backward compatible)
+     * scaleStatsForRarity({ STR: 16, DEX: 12, CON: 14 }, 'elite');
+     * // Returns: { STR: 17, DEX: 13, CON: 15 } (1.07x multiplier - minor complexity boost)
+     *
+     * // With fractional CR (CR 0.25 = 75% stats before rarity)
+     * scaleStatsForRarity({ STR: 16, DEX: 12, CON: 14 }, 'elite', 0.25);
+     * // Returns: { STR: 13, DEX: 10, CON: 11 } (0.75 * 1.07 = 0.8025x multiplier)
+     * ```
+     */
+    private static scaleStatsForRarity;
+    /**
+     * Get an enemy template by ID
+     *
+     * Searches the default enemy templates for a matching ID.
+     *
+     * @param id - Template ID (e.g., 'orc', 'goblin-archer')
+     * @returns Template if found, undefined otherwise
+     *
+     * @example
+     * ```typescript
+     * const orc = getTemplateById('orc');
+     * if (orc) {
+     *   console.log(orc.name); // 'Orc'
+     * }
+     * ```
+     */
+    static getTemplateById(id: string): EnemyTemplate | undefined;
+    /**
+     * Select a template based on filters and audio profile
+     *
+     * Filters templates by category/archetype if specified.
+     * If audio profile is provided, weights selection by audio preference.
+     *
+     * @param rng - Seeded RNG for deterministic selection
+     * @param category - Optional category filter
+     * @param archetype - Optional archetype filter
+     * @param audioProfile - Optional audio profile for weighting
+     * @returns Selected enemy template
+     */
+    private static selectTemplate;
+    /**
+     * Select template using audio profile for weighting
+     *
+     * Calculates weight for each template based on audio preference match:
+     * - bass_dominance → bass weight
+     * - mid_dominance → mid weight
+     * - treble_dominance → treble weight
+     *
+     * Simple dot product approach: multiply audio values by template weights.
+     *
+     * @param templates - Candidate templates
+     * @param audioProfile - Audio profile for weighting
+     * @param rng - RNG for final selection
+     * @returns Selected template
+     */
+    private static weightedSelectionByAudio;
+    /**
+     * Generate a signature ability with rarity-scaled damage die
+     *
+     * Creates a Feature-compatible object from the template's signature ability,
+     * scaling the damage die based on rarity tier and computing damage modifier
+     * from actual scaled ability scores.
+     *
+     * @param signatureAbility - Base signature ability from template
+     * @param rarity - Rarity tier for die scaling
+     * @param scaledStats - Scaled ability scores for damage modifier computation
+     * @param level - Effective level for damage modifier scaling
+     * @param archetype - Enemy archetype for determining primary stat
+     * @returns Scaled signature ability as a feature object
+     */
+    private static scaleSignatureAbility;
+    /**
+     * Boss title suffixes for name generation
+     *
+     * Used to add epic titles to boss enemies.
+     */
+    private static readonly BOSS_TITLES;
+    /**
+     * Boss title prefixes for name generation
+     *
+     * Alternative title format for boss enemies.
+     */
+    private static readonly BOSS_PREFIXES;
+    /**
+     * Generate boss-specific name enhancements
+     *
+     * Adds epic title or prefix to boss name for flavor.
+     * Format options:
+     * - "{name}, {title}" (e.g., "Orc, the Destroyer")
+     * - "{prefix} {name}" (e.g., "Great Orc")
+     * - "{name} of {realm}" (e.g., "Orc of the Void")
+     *
+     * @param baseName - Base enemy name from template
+     * @param rng - Seeded RNG for deterministic selection
+     * @returns Enhanced boss name
+     *
+     * @example
+     * ```typescript
+     * generateBossName('Orc', rng); // "Orc, the Destroyer"
+     * generateBossName('Bear', rng); // "Great Bear"
+     * generateBossName('Dragon', rng); // "Dragon of the Void"
+     * ```
+     */
+    private static generateBossName;
+    /**
+     * Generate boss-specific ability enhancements
+     *
+     * For boss rarity, enhances the signature ability and adds an ultimate ability:
+     * - Signature ability damage dice are doubled (d12 → 2d12)
+     * - Ultimate ability: One powerful ability usable once per encounter
+     *
+     * @param template - Enemy template
+     * @param signatureAbility - Already scaled signature ability
+     * @param rng - Seeded RNG for deterministic selection
+     * @returns Array of boss-enhanced abilities
+     *
+     * @example
+     * ```typescript
+     * const bossFeatures = generateBossFeatures(orcTemplate, scaledSignature, rng);
+     * // Returns: [enhancedSignatureAbility, ultimateAbility]
+     * ```
+     */
+    private static generateBossFeatures;
+    /**
+     * Generate an ultimate ability for boss enemies
+     *
+     * Creates a powerful ability usable once per encounter.
+     * Each archetype has its own pool of ultimate abilities.
+     *
+     * @param archetype - Enemy archetype for ability selection
+     * @param rng - Seeded RNG for deterministic selection
+     * @returns Ultimate ability as a feature object
+     */
+    private static generateUltimateAbility;
+    /**
+     * Generate all abilities for an enemy
+     *
+     * Returns an array containing:
+     * 1. The signature ability (scaled by rarity)
+     * 2. Extra abilities selected from FeatureQuery based on archetype
+     *
+     * @param template - Enemy template
+     * @param rarity - Enemy rarity tier
+     * @param rng - Seeded RNG for deterministic selection
+     * @param scaledStats - Scaled ability scores for damage modifier computation
+     * @param level - Effective level for damage modifier scaling
+     * @returns Array of ability objects compatible with CharacterSheet
+     *
+     * @example
+     * ```typescript
+     * const abilities = generateAbilities(orcTemplate, 'elite', rng, undefined, scaledStats, level);
+     * // Returns: [scaledSignatureAbility, extraFeature1, extraFeature2]
+     * ```
+     */
+    private static generateAbilities;
+    /**
+     * Select extra abilities from FeatureQuery based on archetype
+     *
+     * Filters class features by archetype-appropriate tags and randomly
+     * selects the requested number of abilities.
+     *
+     * @param archetype - Enemy archetype for tag filtering
+     * @param count - Number of abilities to select
+     * @param rng - Seeded RNG for deterministic selection
+     * @returns Array of selected feature objects
+     */
+    private static selectExtraAbilities;
+    /**
+     * Generate a single enemy character
+     *
+     * Creates a CharacterSheet representing an enemy with:
+     * - Template-based stats scaled by rarity
+     * - Audio-influenced stat adjustments (when audioProfile provided)
+     * - Signature ability with scaled damage die
+     * - Extra abilities from FeatureQuery (for higher rarities)
+     * - Resistances for Elite+ tiers
+     *
+     * Audio influence applies subtle stat bonuses based on frequency dominance:
+     * - Bass → STR/CON, Treble → DEX, Mid → WIS/CHA, Balanced → +1 to all
+     * - Maximum +2 increase per stat from audio (capped)
+     *
+     * @param options - Generation options
+     * @returns Enemy character sheet
+     *
+     * @throws Error if templateId not found
+     * @throws Error if audioProfile provided without track
+     *
+     * @example
+     * ```typescript
+     * // Generate a specific elite orc
+     * const orc = EnemyGenerator.generate({
+     *   seed: 'my-encounter',
+     *   templateId: 'orc',
+     *   rarity: 'elite'
+     * });
+     *
+     * // Generate with audio influence (bass-heavy audio → stronger STR/CON)
+     * const enemy = EnemyGenerator.generate({
+     *   seed: 'battle-1',
+     *   audioProfile: { bass_dominance: 0.8, mid_dominance: 0.1, treble_dominance: 0.1 },
+     *   track: trackData,
+     *   rarity: 'uncommon'
+     * });
+     * ```
+     */
+    static generate(options: EnemyGenerationOptions): CharacterSheet;
+    /**
+     * Get character level based on Challenge Rating
+     *
+     * In D&D 5e, CR is approximately equal to level for most creatures.
+     * A CR 5 enemy is roughly equivalent to a level 5 character.
+     *
+     * This method uses CRLevelConverter.crToLevel() for the conversion,
+     * which handles:
+     * - CR 0.25 → level 0.25 (sub-level enemy, reduced base stats)
+     * - CR 0.5 → level 0.5 (sub-level enemy, reduced base stats)
+     * - CR 1+ → level = CR (standard mapping)
+     *
+     * Fractional CRs represent "sub-level" enemies that are weaker than
+     * a level 1 character. These should have reduced stats applied via
+     * getStatMultiplierForFractionalCR().
+     *
+     * @param cr - Challenge Rating (supports fractional values like 0.25, 0.5)
+     * @returns Character level (may be fractional for sub-level enemies)
+     *
+     * @example
+     * ```typescript
+     * getLevelFromCR(0.25); // 0.25 (sub-level)
+     * getLevelFromCR(0.5);  // 0.5 (sub-level)
+     * getLevelFromCR(1);    // 1
+     * getLevelFromCR(5);    // 5
+     * getLevelFromCR(10);   // 10
+     * ```
+     */
+    private static getLevelFromCR;
+    /**
+     * Get stat multiplier for fractional CR enemies
+     *
+     * Sub-level enemies (CR < 1) have reduced base stats to represent
+     * their weaker nature. Uses the continuous formula from StatScaling:
+     * - CR 0.125: ~0.56x
+     * - CR 0.25:  ~0.63x
+     * - CR 0.5:   ~0.75x
+     * - CR 1.0:   1.0x
+     *
+     * @param cr - Challenge Rating (supports fractional values)
+     * @returns Stat multiplier
+     */
+    private static getStatMultiplierForFractionalCR;
+    /**
+     * Get damage die notation for rarity
+     *
+     * Returns the die size used for damage based on rarity tier.
+     *
+     * @param rarity - Enemy rarity tier
+     * @returns Die notation (e.g., 'd6', 'd8')
+     */
+    private static getDamageDieForRarity;
+    /**
+     * Generate a CR from rarity for encounter calculations
+     *
+     * Maps rarity tiers to approximate Challenge Rating values.
+     * Common: CR 1/4, Uncommon: CR 1/2, Elite: CR 1, Boss: CR 2
+     *
+     * @param rarity - Enemy rarity tier
+     * @returns Approximate CR value
+     */
+    private static getCRForRarity;
+    /**
+     * Estimate DPR from weapon damage stats.
+     *
+     * Simple estimate used for HP/DPR ratio enforcement.
+     * Computes average damage per round assuming one attack against AC 15.
+     */
+    private static estimateWeaponDPR;
+    /**
+     * Get the minimum HP/DPR ratio for a given CR.
+     *
+     * Smoothly increases so higher-CR enemies survive more rounds:
+     * - CR 1:  3.0x (3 rounds)
+     * - CR 10: ~3.9x
+     * - CR 15: ~4.5x
+     * - CR 20: ~5.0x
+     * - CR 30: 6.0x (6 rounds)
+     */
+    private static getMinHPRatio;
+    /**
+     * Generate a balanced encounter for a party
+     *
+     * Uses PartyAnalyzer to determine appropriate enemy strength based on party level
+     * and desired difficulty. Supports leader promotion for larger groups.
+     *
+     * @param party - Array of party members' character sheets
+     * @param options - Encounter generation options
+     * @returns Array of generated enemies
+     *
+     * @throws Error if baseRarity='boss' and count > 1 (boss encounters must be single enemy)
+     *
+     * @example
+     * ```typescript
+     * const enemies = EnemyGenerator.generateEncounter(party, {
+     *   seed: 'dungeon-1',
+     *   difficulty: 'medium',
+     *   count: 5
+     * });
+     * // Returns 5 enemies balanced for the party's level
+     * // One enemy will be promoted to uncommon as leader
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Boss encounters must be single enemy (1vparty design)
+     * const boss = EnemyGenerator.generateEncounter(party, {
+     *   seed: 'boss-fight',
+     *   difficulty: 'deadly',
+     *   count: 1,
+     *   baseRarity: 'boss'
+     * });
+     * // Returns 1 boss enemy designed for solo encounter
+     * ```
+     */
+    static generateEncounter(party: CharacterSheet[], options: EncounterGenerationOptions): CharacterSheet[];
+    /**
+     * Generate an encounter based on target CR (no party needed)
+     *
+     * Creates enemies at a specific Challenge Rating, independent of any party.
+     * Useful for pre-planned encounters or when the party strength is unknown.
+     *
+     * @param options - Encounter generation options (must include targetCR)
+     * @returns Array of generated enemies
+     *
+     * @throws Error if baseRarity='boss' and count > 1 (boss encounters must be single enemy)
+     *
+     * @example
+     * ```typescript
+     * const enemies = EnemyGenerator.generateEncounterByCR({
+     *   seed: 'cr5-encounter',
+     *   targetCR: 5,
+     *   count: 3
+     * });
+     * // Returns 3 enemies at approximately CR 5 each
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Boss encounters must be single enemy (1vparty design)
+     * const boss = EnemyGenerator.generateEncounterByCR({
+     *   seed: 'boss-fight',
+     *   targetCR: 10,
+     *   count: 1,
+     *   baseRarity: 'boss'
+     * });
+     * // Returns 1 boss enemy designed for solo encounter
+     * ```
+     */
+    static generateEncounterByCR(options: EncounterGenerationOptions): CharacterSheet[];
+    /**
+     * Select templates for each enemy in an encounter based on mix mode
+     *
+     * Handles uniform, custom, category, and random mix modes.
+     *
+     * @param count - Number of enemies to generate
+     * @param rng - Seeded RNG for deterministic selection
+     * @param enemyMix - Mix mode to use
+     * @param templates - Custom template list for 'custom' mode
+     * @param category - Category filter for 'category' mode
+     * @param archetype - Archetype filter
+     * @param audioProfile - Optional audio profile for weighting
+     * @returns Array of selected templates (one per enemy)
+     */
+    private static selectTemplatesForMix;
+    /**
+     * Apply leader promotion to a group of enemies
+     *
+     * Promotes one or more enemies to higher rarity tiers based on group size.
+     * This creates "leader" enemies that are stronger than their followers.
+     *
+     * Promotion rules:
+     * - 4-6 enemies: 1 enemy promoted +1 tier
+     * - 7-9 enemies: 1 enemy promoted +2 tiers
+     * - 10+ enemies: 2 enemies promoted (1 one tier, 1 two tiers)
+     *
+     * @param enemies - Array of generated enemies (will be modified in place)
+     * @param rng - Seeded RNG for deterministic selection
+     * @param baseRarity - The base rarity before promotion
+     */
+    private static applyLeaderPromotion;
+    /**
+     * Promote a rarity by a number of tiers
+     *
+     * Increases rarity tier by specified amount, capped at 'boss'.
+     *
+     * @param currentRarity - Starting rarity
+     * @param tiers - Number of tiers to promote
+     * @returns Promoted rarity (capped at 'boss')
+     *
+     * @example
+    // =========================================
+    // CR-Based Gradual Rarity Scaling (Task 2.3)
+    // =========================================
+
+    /**
+     * CR tier definitions for gradual rarity scaling
+     *
+     * When scaleRarityWithCR is enabled, higher CR encounters
+     * automatically include upgraded rarities to match difficulty.
+     */
+    private static readonly CR_TIERS;
+    /**
+     * Calculate the number of rarity upgrade points based on CR
+     *
+     * Higher CR encounters get more upgrade points to distribute
+     * across enemies, creating more challenging encounters.
+     *
+     * @param cr - Challenge Rating
+     * @returns Number of upgrade points to distribute
+     *
+     * @example
+     * ```typescript
+     * calculateUpgradePoints(1);  // 0 (Low tier)
+     * calculateUpgradePoints(4);  // 1 (Low-Medium tier)
+     * calculateUpgradePoints(8);  // 2 (Medium tier)
+     * calculateUpgradePoints(18); // 4 (High tier)
+     * calculateUpgradePoints(35); // 6 (Epic tier)
+     * ```
+     */
+    private static calculateUpgradePoints;
+    /**
+     * Upgrade rarity by one step, capped at elite
+     *
+     * CR-based scaling caps at 'elite' to preserve 'boss' for
+     * explicit boss encounters only.
+     *
+     * @param rarity - Current rarity
+     * @returns Upgraded rarity (capped at elite)
+     */
+    private static upgradeRarity;
+    /**
+     * Calculate rarity distribution for enemies based on CR
+     *
+     * Distributes upgrade points across enemies one at a time,
+     * ensuring even distribution of upgraded enemies.
+     *
+     * @param enemyCount - Number of enemies in the encounter
+     * @param cr - Challenge Rating
+     * @returns Array of rarities (one per enemy)
+     *
+     * @example
+     * ```typescript
+     * getRarityDistribution(3, 1);  // [common, common, common]
+     * getRarityDistribution(3, 4);  // [uncommon, common, common]
+     * getRarityDistribution(3, 8);  // [uncommon, uncommon, common]
+     * getRarityDistribution(3, 18); // [elite, uncommon, uncommon]
+     * getRarityDistribution(3, 35); // [elite, elite, elite]
+     * ```
+     */
+    private static getRarityDistribution;
+    /**
+     * Promote rarity by a number of tiers
+     *
+     * Used by leader promotion system. Caps at boss tier.
+     *
+     * @param currentRarity - Starting rarity
+     * @param tiers - Number of tiers to promote
+     * @returns Promoted rarity
+     *
+     * @example
+     * ```typescript
+     * promoteRarity('common', 1); // 'uncommon'
+     * promoteRarity('uncommon', 2); // 'boss'
+     * promoteRarity('elite', 5); // 'boss' (capped)
+     * ```
+     */
+    private static promoteRarity;
+}
+//# sourceMappingURL=EnemyGenerator.d.ts.map

package/dist/core/generation/EnemyGenerator.d.ts.map

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