playlist-data-engine 1.1.0

package/dist/constants/EncounterBalance.d.ts

@@ -0,0 +1,208 @@
+/**
+ * Encounter Balance Constants
+ *
+ * D&D 5e official encounter building tables for calculating balanced encounters.
+ * Based on Dungeon Master's Guide (2014) Chapter 13: Building Combat Encounters.
+ *
+ * These tables provide:
+ * - XP thresholds per character level for each difficulty (easy/medium/hard/deadly)
+ * - CR to XP conversion for calculating monster strength
+ * - Encounter multipliers for adjusting XP budgets based on number of enemies
+ * - Tuning factors for fine-tuning encounter difficulty
+ */
+import type { EncounterDifficulty } from '../core/types/Enemy.js';
+/**
+ * XP Budget Per Character Level
+ *
+ * For each character level and difficulty, defines the XP budget for a SINGLE character.
+ * Multiply by party size to get the total encounter XP budget.
+ *
+ * From D&D 5e Dungeon Master's Guide, page 82, "XP Thresholds by Character Level"
+ *
+ * Usage:
+ * - Calculate party's average level
+ * - Look up threshold per character for desired difficulty
+ * - Multiply by number of party members
+ * - Result is the total XP budget for the encounter
+ */
+export declare const XP_BUDGET_PER_LEVEL: Record<number, Record<EncounterDifficulty, number>>;
+/**
+ * CR to XP Mapping
+ *
+ * Maps Challenge Rating (CR) to Experience Point (XP) values.
+ * Used to determine the strength of monsters and calculate encounter budgets.
+ *
+ * From D&D 5e Monster Manual, "Monsters by Challenge Rating"
+ *
+ * Fractional CRs are supported as decimal values.
+ * Note: CR 0 creatures (commoners) are worth 0 or 10 XP depending on context.
+ * CR 25 does not exist in standard 5e (jumps from 24 to 26).
+ */
+export declare const CR_TO_XP: Record<number, number>;
+/**
+ * Enemy Count Multiplier (Encounter Multipliers)
+ *
+ * Adjusts XP budget for encounters with multiple enemies.
+ * Accounts for action economy advantage and tactical complexity.
+ *
+ * From D&D 5e Dungeon Master's Guide, page 82, "Encounter Multipliers"
+ *
+ * IMPORTANT: These multipliers are applied to the ADJUSTED XP total, not base XP.
+ * Formula: (sum of monster XP) × (encounter multiplier) = adjusted XP
+ *
+ * Special rule: If the party has 6+ members, use the next lowest multiplier.
+ *
+ * The multiplier curve reflects:
+ * - 1 enemy: Full XP worth (×1), but some sources suggest ×1.5 for solo monsters
+ * - 2 enemies: Significantly harder due to action economy (×2)
+ * - 3-6 enemies: Peak action economy advantage (×2.5)
+ * - 7-10 enemies: Diminishing returns due to crowd control (×2)
+ * - 11-14 enemies: More manageable due to AOE effectiveness (×1.5)
+ * - 15+ enemies: Easy to manage with AOE and crowd control (×1)
+ */
+export declare const ENEMY_COUNT_MULTIPLIER: Record<number, number>;
+/**
+ * Tuning Factors for encounter difficulty adjustment
+ *
+ * Allows fine-tuning of encounter difficulty beyond the standard D&D 5e calculations.
+ * These can be adjusted based on party composition, desired pacing, or game balance needs.
+ */
+export declare const TUNING_FACTORS: {
+    /** Default tuning factor (no adjustment) */
+    readonly DEFAULT: 1;
+    /** 10% easier encounters */
+    readonly EASIER: 0.9;
+    /** 20% easier encounters */
+    readonly MUCH_EASIER: 0.8;
+    /** 10% harder encounters */
+    readonly HARDER: 1.1;
+    /** 20% harder encounters */
+    readonly MUCH_HARDER: 1.2;
+    /** 50% harder encounters (for veteran players) */
+    readonly BRUTAL: 1.5;
+};
+/**
+ * Get the XP budget for a single character at a given level and difficulty
+ *
+ * @param level - Character level (1-20)
+ * @param difficulty - Encounter difficulty (easy/medium/hard/deadly)
+ * @returns XP budget for a single character, or 0 if level out of range
+ *
+ * @example
+ * ```typescript
+ * const level5Medium = getXPBudgetPerLevel(5, 'medium'); // 500
+ * const level10Hard = getXPBudgetPerLevel(10, 'hard'); // 1800
+ * ```
+ */
+export declare function getXPBudgetPerLevel(level: number, difficulty: EncounterDifficulty): number;
+/**
+ * Get the total XP budget for a party based on levels and difficulty
+ *
+ * @param levels - Array of character levels in the party
+ * @param difficulty - Encounter difficulty (easy/medium/hard/deadly)
+ * @returns Total XP budget for the entire party
+ *
+ * @example
+ * ```typescript
+ * const party = [3, 3, 4, 5]; // Mixed levels
+ * const budget = getXPBudgetForParty(party, 'medium'); // Sum of individual budgets
+ * ```
+ */
+export declare function getXPBudgetForParty(levels: number[], difficulty: EncounterDifficulty): number;
+/**
+ * Get the XP value for a given Challenge Rating
+ *
+ * @param cr - Challenge Rating (supports decimals like 0.125, 0.25, 0.5)
+ * @returns XP value for that CR, or 0 if CR not found
+ *
+ * @example
+ * ```typescript
+ * getXPForCR(1); // 200
+ * getXPForCR(0.25); // 50
+ * getXPForCR(5); // 1800
+ * ```
+ */
+export declare function getXPForCR(cr: number): number;
+/**
+ * Get the approximate Challenge Rating from an XP value
+ *
+ * Uses binary search to find the CR with closest XP value without exceeding.
+ *
+ * @param xp - Experience point value
+ * @returns CR value, or 0 if no match found
+ *
+ * @example
+ * ```typescript
+ * getCRFromXP(200); // 1
+ * getCRFromXP(1800); // 5
+ * getCRFromXP(3500); // ~7 (returns closest CR without exceeding)
+ * ```
+ */
+export declare function getCRFromXP(xp: number): number;
+/**
+ * Apply a tuning factor to an XP budget
+ *
+ * @param xpBudget - Base XP budget
+ * @param tuningFactor - Multiplier to apply (default: 1.0)
+ * @returns Adjusted XP budget
+ *
+ * @example
+ * ```typescript
+ * applyTuning(1000, 1.2); // 1200 (20% harder)
+ * applyTuning(1000, TUNING_FACTORS.EASIER); // 900
+ * ```
+ */
+export declare function applyTuning(xpBudget: number, tuningFactor?: number): number;
+/**
+ * Get the encounter multiplier for a given number of enemies
+ *
+ * @param enemyCount - Number of enemies in the encounter
+ * @returns Encounter multiplier value
+ *
+ * @example
+ * ```typescript
+ * getEncounterMultiplier(1); // 1.0
+ * getEncounterMultiplier(5); // 2.0
+ * getEncounterMultiplier(15); // 1.0
+ * ```
+ */
+export declare function getEncounterMultiplier(enemyCount: number): number;
+/**
+ * Calculate adjusted XP for a group of enemies
+ *
+ * Applies encounter multiplier to account for action economy.
+ *
+ * @param enemyCRs - Array of enemy Challenge Ratings
+ * @param enemyCountMultiplier - Optional override for enemy count multiplier
+ * @returns Adjusted XP value for encounter building
+ *
+ * @example
+ * ```typescript
+ * // Five CR 1/2 goblins
+ * calculateAdjustedXP([0.5, 0.5, 0.5, 0.5, 0.5]); // 500 (250 base × 2.0)
+ *
+ * // One CR 5 boss
+ * calculateAdjustedXP([5]); // 1800 (1800 base × 1.0)
+ * ```
+ */
+export declare function calculateAdjustedXP(enemyCRs: number[], enemyCountMultiplier?: number): number;
+/**
+ * Get average party level
+ *
+ * @param levels - Array of character levels
+ * @returns Average level (rounded down to integer)
+ *
+ * @example
+ * ```typescript
+ * getAveragePartyLevel([1, 2, 3, 5]); // 2 (11 / 4 = 2.75, rounded down)
+ * ```
+ */
+export declare function getAveragePartyLevel(levels: number[]): number;
+/**
+ * Type guard to validate a difficulty level
+ *
+ * @param value - Value to check
+ * @returns True if valid EncounterDifficulty
+ */
+export declare function isValidEncounterDifficulty(value: unknown): value is EncounterDifficulty;
+//# sourceMappingURL=EncounterBalance.d.ts.map

package/dist/constants/EncounterBalance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EncounterBalance.d.ts","sourceRoot":"","sources":["../../src/constants/EncounterBalance.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAC;AAElE;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,mBAAmB,EAAE,MAAM,CACpC,MAAM,EACN,MAAM,CAAC,mBAAmB,EAAE,MAAM,CAAC,CAsBtC,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAmC3C,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,sBAAsB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAgBzD,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,cAAc;IACvB,4CAA4C;;IAG5C,4BAA4B;;IAG5B,4BAA4B;;IAG5B,4BAA4B;;IAG5B,4BAA4B;;IAG5B,kDAAkD;;CAE5C,CAAC;AAEX;;;;;;;;;;;;GAYG;AACH,wBAAgB,mBAAmB,CAC/B,KAAK,EAAE,MAAM,EACb,UAAU,EAAE,mBAAmB,GAChC,MAAM,CAMR;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,mBAAmB,CAC/B,MAAM,EAAE,MAAM,EAAE,EAChB,UAAU,EAAE,mBAAmB,GAChC,MAAM,CAIR;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,CAE7C;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,WAAW,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,CA2B9C;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,WAAW,CAAC,QAAQ,EAAE,MAAM,EAAE,YAAY,GAAE,MAAY,GAAG,MAAM,CAEhF;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,sBAAsB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAIjE;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,mBAAmB,CAC/B,QAAQ,EAAE,MAAM,EAAE,EAClB,oBAAoB,CAAC,EAAE,MAAM,GAC9B,MAAM,CAQR;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM,CAI7D;AAED;;;;;GAKG;AACH,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,mBAAmB,CAGvF"}

package/dist/constants/EnemyEquipment.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Enemy Equipment Templates
+ *
+ * Equipment templates specifically designed for enemy generation.
+ * These templates map to equipment in the main DEFAULT_EQUIPMENT database
+ * but are organized by archetype and rarity for enemy generation.
+ *
+ * Equipment selection follows these rules:
+ * - Brute: Heavy damage weapons (greataxe, longsword), heavy armor (scale mail, chain mail)
+ * - Archer: Ranged weapons (longbow, light crossbow), light armor (leather), backup dagger
+ * - Support: Quarterstaff or mace, light armor with shield option
+ *
+ * Higher rarity enemies receive better equipment from their available pool.
+ */
+import type { EquipmentTemplate } from '../core/types/Enemy.js';
+import type { EnemyArchetype, EnemyRarity } from '../core/types/Enemy.js';
+/**
+ * Map equipment template to actual equipment name in DEFAULT_EQUIPMENT
+ *
+ * This is the bridge between enemy equipment templates and the actual
+ * equipment database. When generating an enemy, we look up the actual
+ * equipment by name.
+ */
+export declare const ENEMY_EQUIPMENT_MAPPING: Record<string, string>;
+/**
+ * Enemy equipment templates
+ *
+ * Organized by archetype with equipment options that scale by rarity.
+ * Higher rarity enemies get better equipment from the archetype pool.
+ */
+export declare const ENEMY_EQUIPMENT_TEMPLATES: EquipmentTemplate[];
+/**
+ * Get equipment templates by archetype
+ *
+ * @param archetype - The enemy archetype to filter by
+ * @returns Array of equipment templates for the archetype
+ */
+export declare function getEquipmentByArchetype(archetype: EnemyArchetype): EquipmentTemplate[];
+/**
+ * Get equipment templates by archetype and rarity
+ *
+ * @param archetype - The enemy archetype to filter by
+ * @param rarity - The rarity tier to filter by
+ * @returns Array of equipment templates matching both criteria
+ */
+export declare function getEquipmentByArchetypeAndRarity(archetype: EnemyArchetype, rarity: EnemyRarity): EquipmentTemplate[];
+/**
+ * Get weapons by archetype and rarity
+ *
+ * @param archetype - The enemy archetype to filter by
+ * @param rarity - The rarity tier to filter by
+ * @returns Array of weapon templates matching both criteria
+ */
+export declare function getWeaponsByArchetypeAndRarity(archetype: EnemyArchetype, rarity: EnemyRarity): EquipmentTemplate[];
+/**
+ * Get armor by archetype and rarity
+ *
+ * @param archetype - The enemy archetype to filter by
+ * @param rarity - The rarity tier to filter by
+ * @returns Array of armor templates matching both criteria
+ */
+export declare function getArmorByArchetypeAndRarity(archetype: EnemyArchetype, rarity: EnemyRarity): EquipmentTemplate[];
+/**
+ * Get shields by archetype and rarity
+ *
+ * @param archetype - The enemy archetype to filter by
+ * @param rarity - The rarity tier to filter by
+ * @returns Array of shield templates matching both criteria
+ */
+export declare function getShieldsByArchetypeAndRarity(archetype: EnemyArchetype, rarity: EnemyRarity): EquipmentTemplate[];
+//# sourceMappingURL=EnemyEquipment.d.ts.map

package/dist/constants/EnemyEquipment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EnemyEquipment.d.ts","sourceRoot":"","sources":["../../src/constants/EnemyEquipment.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAChE,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAE1E;;;;;;GAMG;AACH,eAAO,MAAM,uBAAuB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAsB1D,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,yBAAyB,EAAE,iBAAiB,EAoKxD,CAAC;AAEF;;;;;GAKG;AACH,wBAAgB,uBAAuB,CAAC,SAAS,EAAE,cAAc,GAAG,iBAAiB,EAAE,CAItF;AAED;;;;;;GAMG;AACH,wBAAgB,gCAAgC,CAC5C,SAAS,EAAE,cAAc,EACzB,MAAM,EAAE,WAAW,GACpB,iBAAiB,EAAE,CAKrB;AAED;;;;;;GAMG;AACH,wBAAgB,8BAA8B,CAC1C,SAAS,EAAE,cAAc,EACzB,MAAM,EAAE,WAAW,GACpB,iBAAiB,EAAE,CAIrB;AAED;;;;;;GAMG;AACH,wBAAgB,4BAA4B,CACxC,SAAS,EAAE,cAAc,EACzB,MAAM,EAAE,WAAW,GACpB,iBAAiB,EAAE,CAIrB;AAED;;;;;;GAMG;AACH,wBAAgB,8BAA8B,CAC1C,SAAS,EAAE,cAAc,EACzB,MAAM,EAAE,WAAW,GACpB,iBAAiB,EAAE,CAIrB"}

package/dist/constants/EnemyRarity.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Enemy Rarity Configuration
+ *
+ * Defines scaling factors and properties for each enemy rarity tier.
+ * Rarity controls **complexity**, not power. CR handles power scaling.
+ *
+ * Design Principle: Any CR can combine with any rarity:
+ * - CR 0.25 + Boss = Goblin chieftain (weak but complex)
+ * - CR 20 + Common = Ancient beast (powerful but simple)
+ *
+ * Rarity progression (complexity-based, minimal stat impact):
+ * - Common: Base enemy with standard stats
+ * - Uncommon: Minor stat adjustment, stronger signature ability, 1 extra ability
+ * - Elite: Small stat adjustment, stronger signature ability, 2 extra abilities, gains resistances
+ * - Boss: Moderate stat adjustment, strongest signature ability, 3 extra abilities, legendary actions
+ */
+import type { EnemyRarity, RarityConfig } from '../core/types/Enemy.js';
+/**
+ * Rarity configuration for each enemy tier
+ *
+ * These values define how enemies scale across rarity tiers:
+ * - statMultiplier: Multiplier applied to base ability scores
+ * - hpMultiplier: Separate HP multiplier for dramatic health differences between rarities
+ * - signatureDieSize: Number of sides on signature ability damage die (d6/d8/d10/d12)
+ * - extraAbilityCount: Number of additional abilities from FeatureQuery pool
+ * - hasResistances: Whether this rarity gains template resistances/immunities
+ *
+ * Common is the baseline. Higher rarities have meaningfully more HP and
+ * stronger ability scores, making them feel distinctly more powerful.
+ */
+export declare const RARITY_CONFIGS: Record<EnemyRarity, RarityConfig>;
+/**
+ * Get the rarity configuration for a given rarity tier
+ *
+ * @param rarity - The enemy rarity tier
+ * @returns The configuration for that rarity, or undefined if invalid rarity
+ *
+ * @example
+ * ```typescript
+ * const eliteConfig = getRarityConfig('elite');
+ * console.log(eliteConfig.statMultiplier); // 1.25
+ * console.log(eliteConfig.signatureDieSize); // 10
+ * ```
+ */
+export declare function getRarityConfig(rarity: EnemyRarity): RarityConfig;
+/**
+ * Get the die notation string for a given rarity's signature ability
+ *
+ * @param rarity - The enemy rarity tier
+ * @returns Die notation string (e.g., 'd6', 'd8', 'd10', 'd12')
+ *
+ * @example
+ * ```typescript
+ * const bossDie = getSignatureDie('boss'); // 'd12'
+ * const commonDie = getSignatureDie('common'); // 'd6'
+ * ```
+ */
+export declare function getSignatureDie(rarity: EnemyRarity): string;
+/**
+ * Get all available rarity tiers
+ *
+ * @returns Array of all rarity tiers in ascending order of power
+ */
+export declare function getAllRarities(): EnemyRarity[];
+/**
+ * Get the next higher rarity tier
+ *
+ * @param currentRarity - The current rarity tier
+ * @returns The next higher rarity, or undefined if already at boss
+ *
+ * @example
+ * ```typescript
+ * getHigherRarity('common'); // 'uncommon'
+ * getHigherRarity('elite'); // 'boss'
+ * getHigherRarity('boss'); // undefined
+ * ```
+ */
+export declare function getHigherRarity(currentRarity: EnemyRarity): EnemyRarity | undefined;
+//# sourceMappingURL=EnemyRarity.d.ts.map

package/dist/constants/EnemyRarity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EnemyRarity.d.ts","sourceRoot":"","sources":["../../src/constants/EnemyRarity.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAExE;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,cAAc,EAAE,MAAM,CAAC,WAAW,EAAE,YAAY,CA6B5D,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,WAAW,GAAG,YAAY,CAEjE;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,WAAW,GAAG,MAAM,CAE3D;AAED;;;;GAIG;AACH,wBAAgB,cAAc,IAAI,WAAW,EAAE,CAE9C;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,eAAe,CAAC,aAAa,EAAE,WAAW,GAAG,WAAW,GAAG,SAAS,CAOnF"}

package/dist/constants/EnemyTemplates/Construct.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Construct Enemy Templates
+ *
+ * Contains construct enemy templates with category-specific traits:
+ * - Poison immunity (immune to poison damage and poisoned condition)
+ * - Psychic immunity (immune to psychic damage)
+ * - No healing (constructs cannot recover hit points through magical healing)
+ *
+ * Constructs are artificial creatures, often animated objects or built beings.
+ * They are typically immune to poison and psychic effects, and cannot heal
+ * through normal magical means. They are often slow but durable.
+ */
+import type { EnemyTemplate } from '../../core/types/Enemy.js';
+/**
+ * Construct enemy templates
+ *
+ * These 4 templates provide construct enemies with:
+ * - Poison immunity (all rarities)
+ * - Psychic immunity (all rarities)
+ * - Varied archetypes: Brute (Animated Armor, Golem), Archer (Flying Sword), Support (Shield Guardian)
+ */
+export declare const CONSTRUCT_TEMPLATES: EnemyTemplate[];
+/**
+ * Helper function to get a construct template by ID
+ *
+ * @param id - The template ID (e.g., 'animated-armor', 'flying-sword', 'shield-guardian', 'golem')
+ * @returns The matching template, or undefined if not found
+ *
+ * @example
+ * ```typescript
+ * const animatedArmor = getConstructTemplateById('animated-armor');
+ * if (animatedArmor) {
+ *   console.log(animatedArmor.name); // 'Animated Armor'
+ * }
+ * ```
+ */
+export declare function getConstructTemplateById(id: string): EnemyTemplate | undefined;
+/**
+ * Get all construct templates
+ *
+ * @returns Array of all construct templates
+ *
+ * @example
+ * ```typescript
+ * const constructs = getConstructTemplates();
+ * console.log(constructs.length); // 4 (Animated Armor, Flying Sword, Shield Guardian, Golem)
+ * ```
+ */
+export declare function getConstructTemplates(): EnemyTemplate[];
+/**
+ * Get construct templates by archetype
+ *
+ * @param archetype - The enemy archetype ('brute', 'archer', 'support')
+ * @returns Array of construct templates with the specified archetype
+ *
+ * @example
+ * ```typescript
+ * const constructBrutes = getConstructTemplatesByArchetype('brute');
+ * console.log(constructBrutes.length); // 2 (Animated Armor, Golem)
+ * ```
+ */
+export declare function getConstructTemplatesByArchetype(archetype: string): EnemyTemplate[];
+//# sourceMappingURL=Construct.d.ts.map

package/dist/constants/EnemyTemplates/Construct.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Construct.d.ts","sourceRoot":"","sources":["../../../src/constants/EnemyTemplates/Construct.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAE/D;;;;;;;GAOG;AACH,eAAO,MAAM,mBAAmB,EAAE,aAAa,EA8K9C,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,wBAAgB,wBAAwB,CAAC,EAAE,EAAE,MAAM,GAAG,aAAa,GAAG,SAAS,CAE9E;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,qBAAqB,IAAI,aAAa,EAAE,CAEvD;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,gCAAgC,CAAC,SAAS,EAAE,MAAM,GAAG,aAAa,EAAE,CAEnF"}

package/dist/constants/EnemyTemplates/Dragon.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Dragon Enemy Templates
+ *
+ * Contains dragon enemy templates with category-specific traits:
+ * - Damage immunity (by dragon type)
+ * - Frightful presence (for higher rarity)
+ *
+ * Dragons are powerful, intelligent reptilian creatures with breath weapons
+ * and devastating physical attacks. Young dragons are formidable opponents,
+ * while wyrmlings and drakes provide lesser challenges. Each dragon type
+ * has immunity to its associated damage element.
+ */
+import type { EnemyTemplate } from '../../core/types/Enemy.js';
+/**
+ * Dragon enemy templates
+ *
+ * These 4 templates provide dragon enemies with:
+ * - Young Red Dragon: Fire immunity, Fire Breath (AoE fire), bass audio preference
+ * - Young Blue Dragon: Lightning immunity, Lightning Breath (line lightning), treble audio preference
+ * - Dragon Wyrmling: Acid resistance, Bite + Claw (multiattack), mid audio preference
+ * - Drake: Cold resistance, Tail Swipe (knockback), bass audio preference
+ * - Varied archetypes: Brute (Young Red Dragon, Dragon Wyrmling, Drake), Archer (Young Blue Dragon)
+ */
+export declare const DRAGON_TEMPLATES: EnemyTemplate[];
+/**
+ * Helper function to get a dragon template by ID
+ *
+ * @param id - The template ID (e.g., 'young-red-dragon', 'young-blue-dragon', 'dragon-wyrmling', 'drake')
+ * @returns The matching template, or undefined if not found
+ *
+ * @example
+ * ```typescript
+ * const youngRedDragon = getDragonTemplateById('young-red-dragon');
+ * if (youngRedDragon) {
+ *   console.log(youngRedDragon.name); // 'Young Red Dragon'
+ * }
+ * ```
+ */
+export declare function getDragonTemplateById(id: string): EnemyTemplate | undefined;
+/**
+ * Get all dragon templates
+ *
+ * @returns Array of all dragon templates
+ *
+ * @example
+ * ```typescript
+ * const dragons = getDragonTemplates();
+ * console.log(dragons.length); // 4 (Young Red Dragon, Young Blue Dragon, Dragon Wyrmling, Drake)
+ * ```
+ */
+export declare function getDragonTemplates(): EnemyTemplate[];
+/**
+ * Get dragon templates by archetype
+ *
+ * @param archetype - The enemy archetype ('brute', 'archer', 'support')
+ * @returns Array of dragon templates with the specified archetype
+ *
+ * @example
+ * ```typescript
+ * const dragonBrutes = getDragonTemplatesByArchetype('brute');
+ * console.log(dragonBrutes.length); // 3 (Young Red Dragon, Dragon Wyrmling, Drake)
+ *
+ * const dragonArchers = getDragonTemplatesByArchetype('archer');
+ * console.log(dragonArchers.length); // 1 (Young Blue Dragon)
+ * ```
+ */
+export declare function getDragonTemplatesByArchetype(archetype: string): EnemyTemplate[];
+//# sourceMappingURL=Dragon.d.ts.map

package/dist/constants/EnemyTemplates/Dragon.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Dragon.d.ts","sourceRoot":"","sources":["../../../src/constants/EnemyTemplates/Dragon.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAE/D;;;;;;;;;GASG;AACH,eAAO,MAAM,gBAAgB,EAAE,aAAa,EA8K3C,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,wBAAgB,qBAAqB,CAAC,EAAE,EAAE,MAAM,GAAG,aAAa,GAAG,SAAS,CAE3E;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,IAAI,aAAa,EAAE,CAEpD;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,6BAA6B,CAAC,SAAS,EAAE,MAAM,GAAG,aAAa,EAAE,CAEhF"}

package/dist/constants/EnemyTemplates/Elemental.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Elemental Enemy Templates
+ *
+ * Contains elemental enemy templates with category-specific traits:
+ * - Immunity to their own element
+ * - Varied resistances based on element type
+ *
+ * Elementals are living manifestations of natural forces, often found
+ * near their native environments. They are immune to their element
+ * and typically have abilities that reflect their nature.
+ */
+import type { EnemyTemplate } from '../../core/types/Enemy.js';
+/**
+ * Elemental enemy templates
+ *
+ * These 4 templates provide elemental enemies with:
+ * - Fire Elemental: Fire immunity, cold vulnerability
+ * - Water Elemental: Cold immunity, resistance to fire and necrotic
+ * - Air Elemental: Lightning immunity, resistance to thunder
+ * - Earth Elemental: Poison immunity, resistance to necrotic
+ * - Varied archetypes: Brute (Fire, Earth), Support (Water), Archer (Air)
+ */
+export declare const ELEMENTAL_TEMPLATES: EnemyTemplate[];
+/**
+ * Helper function to get an elemental template by ID
+ *
+ * @param id - The template ID (e.g., 'fire-elemental', 'water-elemental', 'air-elemental', 'earth-elemental')
+ * @returns The matching template, or undefined if not found
+ *
+ * @example
+ * ```typescript
+ * const fireElemental = getElementalTemplateById('fire-elemental');
+ * if (fireElemental) {
+ *   console.log(fireElemental.name); // 'Fire Elemental'
+ * }
+ * ```
+ */
+export declare function getElementalTemplateById(id: string): EnemyTemplate | undefined;
+/**
+ * Get all elemental templates
+ *
+ * @returns Array of all elemental templates
+ *
+ * @example
+ * ```typescript
+ * const elementals = getElementalTemplates();
+ * console.log(elementals.length); // 4 (Fire Elemental, Water Elemental, Air Elemental, Earth Elemental)
+ * ```
+ */
+export declare function getElementalTemplates(): EnemyTemplate[];
+/**
+ * Get elemental templates by archetype
+ *
+ * @param archetype - The enemy archetype ('brute', 'archer', 'support')
+ * @returns Array of elemental templates with the specified archetype
+ *
+ * @example
+ * ```typescript
+ * const elementalBrutes = getElementalTemplatesByArchetype('brute');
+ * console.log(elementalBrutes.length); // 2 (Fire Elemental, Earth Elemental)
+ * ```
+ */
+export declare function getElementalTemplatesByArchetype(archetype: string): EnemyTemplate[];
+//# sourceMappingURL=Elemental.d.ts.map

package/dist/constants/EnemyTemplates/Elemental.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Elemental.d.ts","sourceRoot":"","sources":["../../../src/constants/EnemyTemplates/Elemental.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAE/D;;;;;;;;;GASG;AACH,eAAO,MAAM,mBAAmB,EAAE,aAAa,EAkL9C,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,wBAAgB,wBAAwB,CAAC,EAAE,EAAE,MAAM,GAAG,aAAa,GAAG,SAAS,CAE9E;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,qBAAqB,IAAI,aAAa,EAAE,CAEvD;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,gCAAgC,CAAC,SAAS,EAAE,MAAM,GAAG,aAAa,EAAE,CAEnF"}

package/dist/constants/EnemyTemplates/Fiend.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Fiend Enemy Templates
+ *
+ * Contains fiend enemy templates with category-specific traits:
+ * - Fire resistance (half damage from fire attacks)
+ * - Cold resistance (half damage from cold attacks)
+ *
+ * Fiends are malicious creatures from the lower planes, including demons,
+ * devils, and other evil outsiders. They are typically resistant to
+ * fire and cold, and often have poisonous or corrupting abilities.
+ */
+import type { EnemyTemplate } from '../../core/types/Enemy.js';
+/**
+ * Fiend enemy templates
+ *
+ * These 4 templates provide fiend enemies with:
+ * - Fire resistance (all rarities)
+ * - Cold resistance (all rarities)
+ * - Varied archetypes: Archer (Imp), Support (Quasit), Brute (Lemure, Demon)
+ */
+export declare const FIEND_TEMPLATES: EnemyTemplate[];
+/**
+ * Helper function to get a fiend template by ID
+ *
+ * @param id - The template ID (e.g., 'imp', 'quasit', 'lemure', 'demon')
+ * @returns The matching template, or undefined if not found
+ *
+ * @example
+ * ```typescript
+ * const imp = getFiendTemplateById('imp');
+ * if (imp) {
+ *   console.log(imp.name); // 'Imp'
+ * }
+ * ```
+ */
+export declare function getFiendTemplateById(id: string): EnemyTemplate | undefined;
+/**
+ * Get all fiend templates
+ *
+ * @returns Array of all fiend templates
+ *
+ * @example
+ * ```typescript
+ * const fiends = getFiendTemplates();
+ * console.log(fiends.length); // 4 (Imp, Quasit, Lemure, Demon)
+ * ```
+ */
+export declare function getFiendTemplates(): EnemyTemplate[];
+/**
+ * Get fiend templates by archetype
+ *
+ * @param archetype - The enemy archetype ('brute', 'archer', 'support')
+ * @returns Array of fiend templates with the specified archetype
+ *
+ * @example
+ * ```typescript
+ * const fiendBrutes = getFiendTemplatesByArchetype('brute');
+ * console.log(fiendBrutes.length); // 2 (Lemure, Demon)
+ * ```
+ */
+export declare function getFiendTemplatesByArchetype(archetype: string): EnemyTemplate[];
+//# sourceMappingURL=Fiend.d.ts.map

package/dist/constants/EnemyTemplates/Fiend.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Fiend.d.ts","sourceRoot":"","sources":["../../../src/constants/EnemyTemplates/Fiend.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAE/D;;;;;;;GAOG;AACH,eAAO,MAAM,eAAe,EAAE,aAAa,EAkL1C,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,wBAAgB,oBAAoB,CAAC,EAAE,EAAE,MAAM,GAAG,aAAa,GAAG,SAAS,CAE1E;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,IAAI,aAAa,EAAE,CAEnD;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,4BAA4B,CAAC,SAAS,EAAE,MAAM,GAAG,aAAa,EAAE,CAE/E"}