playlist-data-engine 1.1.0

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

@@ -0,0 +1,63 @@
+/**
+ * Monstrosity Enemy Templates
+ *
+ * Contains monstrosity enemy templates with varied traits.
+ * Monstrosities are bizarre creatures that defy normal classification.
+ * Unlike other categories, monstrosities have no universal category traits -
+ * each creature has its own unique abilities and characteristics.
+ *
+ * Monstrosities are often found in wild places, dungeons, or as
+ * guardians of cursed locations. They include hybrids of multiple
+ * creatures and bizarre magical creations.
+ */
+import type { EnemyTemplate } from '../../core/types/Enemy.js';
+/**
+ * Monstrosity enemy templates
+ *
+ * These 4 templates provide monstrosity enemies with:
+ * - Varied resistances (no universal category trait)
+ * - Unique abilities per creature
+ * - Varied archetypes: Brute (Owlbear, Mimic), Archer (Griffin), Support (Basilisk)
+ */
+export declare const MONSTROSITY_TEMPLATES: EnemyTemplate[];
+/**
+ * Helper function to get a monstrosity template by ID
+ *
+ * @param id - The template ID (e.g., 'owlbear', 'griffin', 'mimic', 'basilisk')
+ * @returns The matching template, or undefined if not found
+ *
+ * @example
+ * ```typescript
+ * const owlbear = getMonstrosityTemplateById('owlbear');
+ * if (owlbear) {
+ *   console.log(owlbear.name); // 'Owlbear'
+ * }
+ * ```
+ */
+export declare function getMonstrosityTemplateById(id: string): EnemyTemplate | undefined;
+/**
+ * Get all monstrosity templates
+ *
+ * @returns Array of all monstrosity templates
+ *
+ * @example
+ * ```typescript
+ * const monstrosities = getMonstrosityTemplates();
+ * console.log(monstrosities.length); // 4 (Owlbear, Griffin, Mimic, Basilisk)
+ * ```
+ */
+export declare function getMonstrosityTemplates(): EnemyTemplate[];
+/**
+ * Get monstrosity templates by archetype
+ *
+ * @param archetype - The enemy archetype ('brute', 'archer', 'support')
+ * @returns Array of monstrosity templates with the specified archetype
+ *
+ * @example
+ * ```typescript
+ * const monstrosityBrutes = getMonstrosityTemplatesByArchetype('brute');
+ * console.log(monstrosityBrutes.length); // 2 (Owlbear, Mimic)
+ * ```
+ */
+export declare function getMonstrosityTemplatesByArchetype(archetype: string): EnemyTemplate[];
+//# sourceMappingURL=Monstrosity.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Monstrosity.d.ts","sourceRoot":"","sources":["../../../src/constants/EnemyTemplates/Monstrosity.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAE/D;;;;;;;GAOG;AACH,eAAO,MAAM,qBAAqB,EAAE,aAAa,EAkLhD,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,wBAAgB,0BAA0B,CAAC,EAAE,EAAE,MAAM,GAAG,aAAa,GAAG,SAAS,CAEhF;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,uBAAuB,IAAI,aAAa,EAAE,CAEzD;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,kCAAkC,CAAC,SAAS,EAAE,MAAM,GAAG,aAAa,EAAE,CAErF"}

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

@@ -0,0 +1,61 @@
+/**
+ * Undead Enemy Templates
+ *
+ * Contains undead enemy templates with category-specific traits:
+ * - Necrotic resistance (half damage from necrotic attacks)
+ * - Poison immunity (immune to poison damage and poisoned condition)
+ *
+ * Undead are animated corpses or spirits, often found in graveyards,
+ * tombs, and cursed locations. They typically have dark, eerie audio preferences.
+ */
+import type { EnemyTemplate } from '../../core/types/Enemy.js';
+/**
+ * Undead enemy templates
+ *
+ * These 4 templates provide undead enemies with:
+ * - Necrotic resistance (elite+ rarity scaling)
+ * - Poison immunity (all rarities)
+ * - Varied archetypes: Archer (Skeleton), Brute (Zombie, Wight), Support (Ghost)
+ */
+export declare const UNDEAD_TEMPLATES: EnemyTemplate[];
+/**
+ * Helper function to get an undead template by ID
+ *
+ * @param id - The template ID (e.g., 'skeleton', 'zombie', 'wight', 'ghost')
+ * @returns The matching template, or undefined if not found
+ *
+ * @example
+ * ```typescript
+ * const skeleton = getUndeadTemplateById('skeleton');
+ * if (skeleton) {
+ *   console.log(skeleton.name); // 'Skeleton'
+ * }
+ * ```
+ */
+export declare function getUndeadTemplateById(id: string): EnemyTemplate | undefined;
+/**
+ * Get all undead templates
+ *
+ * @returns Array of all undead templates
+ *
+ * @example
+ * ```typescript
+ * const undead = getUndeadTemplates();
+ * console.log(undead.length); // 4 (Skeleton, Zombie, Wight, Ghost)
+ * ```
+ */
+export declare function getUndeadTemplates(): EnemyTemplate[];
+/**
+ * Get undead templates by archetype
+ *
+ * @param archetype - The enemy archetype ('brute', 'archer', 'support')
+ * @returns Array of undead templates with the specified archetype
+ *
+ * @example
+ * ```typescript
+ * const undeadBrutes = getUndeadTemplatesByArchetype('brute');
+ * console.log(undeadBrutes.length); // 2 (Zombie, Wight)
+ * ```
+ */
+export declare function getUndeadTemplatesByArchetype(archetype: string): EnemyTemplate[];
+//# sourceMappingURL=Undead.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Undead.d.ts","sourceRoot":"","sources":["../../../src/constants/EnemyTemplates/Undead.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAE/D;;;;;;;GAOG;AACH,eAAO,MAAM,gBAAgB,EAAE,aAAa,EAkL3C,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;;;;;;;;;;;GAWG;AACH,wBAAgB,6BAA6B,CAAC,SAAS,EAAE,MAAM,GAAG,aAAa,EAAE,CAEhF"}

package/dist/constants/ItemTemplates.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Item Creation Templates for enchantment
+ *
+ * These templates can be applied to base equipment to create magic variants.
+ * Templates define reusable enchantment patterns that add properties, tags,
+ * and effects to base items.
+ *
+ * Usage: Import `ITEM_CREATION_TEMPLATES` and use template IDs to enchant items.
+ * Templates are applied by the EquipmentModifier and can be extended via ExtensionManager.
+ *
+ * Template types:
+ * - Enhancement bonuses: +1, +2, +3 to weapons and armor
+ * - Elemental weapons: Flaming, Frost, Shocking
+ * - Special effects: Vicious, and other combat enhancements
+ *
+ * @example
+ * ```typescript
+ * import { applyTemplate } from '../utils/magicItemExamples.js';
+ * import { DEFAULT_EQUIPMENT } from './DefaultEquipment.js';
+ * import { ITEM_CREATION_TEMPLATES } from './ItemTemplates.js';
+ *
+ * const baseSword = DEFAULT_EQUIPMENT['Longsword'];
+ * const flamingSword = applyTemplate(baseSword, 'flaming_weapon_template');
+ * ```
+ */
+import type { EnhancedEquipment } from '../core/types/Equipment.js';
+/**
+ * Item Creation Templates for enchantment
+ *
+ * These templates can be applied to base equipment to create magic variants.
+ * Templates define reusable enchantment patterns that add properties, tags,
+ * and effects to base items.
+ *
+ * Template types:
+ * - Enhancement bonuses: +1, +2, +3 to weapons and armor
+ * - Elemental weapons: Flaming, Frost, Shocking
+ * - Special effects: Vicious, and other combat enhancements
+ */
+export declare const ITEM_CREATION_TEMPLATES: Record<string, Partial<EnhancedEquipment>>;
+//# sourceMappingURL=ItemTemplates.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ItemTemplates.d.ts","sourceRoot":"","sources":["../../src/constants/ItemTemplates.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AAEpE;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,uBAAuB,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,iBAAiB,CAAC,CA8K9E,CAAC"}

package/dist/constants/MagicItems.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Magic Items Database
+ *
+ * Example Magic Items demonstrating all equipment system capabilities.
+ *
+ * This collection demonstrates all capabilities of the Advanced Equipment System:
+ * - Equipment properties (stat bonuses, skill proficiencies, ability unlocks, etc.)
+ * - Equipment-granted features (registry features and inline mini-features)
+ * - Equipment-granted skills and spells
+ * - D&D 5e standard stats (damage dice, AC, properties)
+ * - Runtime equipment modification (templates + per-instance)
+ * - Spawn weight system for generation control
+ * - Cursed items with negative effects
+ * - Conditional effects
+ *
+ * These examples can be used as:
+ * 1. Reference for creating custom magic items
+ * 2. Test fixtures for the equipment system
+ * 3. Starting point for ExtensionManager registration
+ *
+ * Previously located in src/utils/equipmentConstants.ts.
+ *
+ * @module constants/MagicItems
+ */
+import type { EnhancedEquipment } from '../core/types/Equipment.js';
+/**
+ * Example Magic Items demonstrating all equipment system capabilities
+ */
+export declare const MAGIC_ITEMS: EnhancedEquipment[];
+//# sourceMappingURL=MagicItems.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"MagicItems.d.ts","sourceRoot":"","sources":["../../src/constants/MagicItems.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AAEpE;;GAEG;AACH,eAAO,MAAM,WAAW,EAAE,iBAAiB,EA2pC1C,CAAC"}

package/dist/constants/SpellSlots.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Spell Slot Constants
+ *
+ * D&D 5e spell slot progression tables for combat use.
+ * Based on Player's Handbook (2014) full caster progression.
+ *
+ * The FULL_CASTER_SLOTS table maps character level (1-20) to an array
+ * of spell slot counts per spell level (index 0 unused, indices 1-9
+ * represent spell levels 1-9).
+ *
+ * This table is the canonical source used by CombatEngine and SpellCaster.
+ * For per-class spell slot data (including half-casters like Paladin/Ranger
+ * and pact-magic casters like Warlock), see SPELL_SLOTS_BY_CLASS in
+ * DefaultSpells.ts.
+ */
+/**
+ * D&D 5e full caster spell slot progression by character level.
+ *
+ * Each entry maps character level → [_, level1, level2, ..., level9].
+ * Index 0 is unused padding to align array indices with spell levels.
+ */
+export declare const FULL_CASTER_SLOTS: Record<number, number[]>;
+/**
+ * Convert FULL_CASTER_SLOTS entry into the flat `{ [level]: number }` format
+ * used by Combatant.spellSlots.
+ */
+export declare function getFullCasterSlotsForLevel(characterLevel: number): {
+    [level: number]: number;
+};
+//# sourceMappingURL=SpellSlots.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SpellSlots.d.ts","sourceRoot":"","sources":["../../src/constants/SpellSlots.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAqBtD,CAAC;AAEF;;;GAGG;AACH,wBAAgB,0BAA0B,CACxC,cAAc,EAAE,MAAM,GACrB;IAAE,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAA;CAAE,CAa7B"}

package/dist/constants/StatScaling.d.ts

@@ -0,0 +1,113 @@
+/**
+ * Stat Level Scaling — Level-based stat scaling functions for enemy generation
+ *
+ * Enables HP, attack, and defense to scale independently at different effective
+ * levels, allowing creative encounter designs (e.g., tanky low-damage enemy or
+ * glass cannon). The AI and simulator don't need to know about this — they read
+ * the final CharacterSheet stats. This is purely a generation-layer concern.
+ *
+ * Design principle: When all three levels match CR, output must be identical
+ * to current generation (backward compatible). The scaling functions compute
+ * what the stats *would be* at a given level, and the generator uses those values.
+ */
+import type { AbilityScores } from '../core/types/Character.js';
+import type { EnemyRarity, EnemyArchetype, EquipmentConfig } from '../core/types/Enemy.js';
+/**
+ * Returns a multiplier for how much a stat increases at a given level vs level 1.
+ *
+ * Uses a logarithmic curve that provides noticeable growth at low levels
+ * but tapers off at high levels, preventing exponential scaling:
+ * - Level 1: 1.0x
+ * - Level 5: 1.24x
+ * - Level 10: 1.44x
+ * - Level 15: 1.59x
+ * - Level 20: 1.70x
+ * - Level 25: 1.84x
+ * - Level 30: 2.015x
+ *
+ * @param level - Effective level (1-30+, supports fractional)
+ * @returns Multiplier where level 1 = 1.0
+ */
+export declare function getLevelScalingFactor(level: number): number;
+/**
+ * Scale HP for a given effective level and rarity.
+ *
+ * Current system: HP = baseHP * rarityMultiplier * fractionalCRMultiplier
+ * New system adds level-based scaling: HP = baseHP * levelFactor * rarityMultiplier * fractionalCRMultiplier
+ *
+ * When level = CR-derived level and no overrides, the levelFactor provides
+ * the missing CR-based HP scaling that the current system lacks.
+ *
+ * @param baseHP - Base HP from enemy template (e.g., 15 for orc)
+ * @param level - Effective HP level (1-30+)
+ * @param rarity - Enemy rarity tier (affects stat multiplier)
+ * @returns Scaled HP value
+ */
+export declare function getHPAtLevel(baseHP: number, level: number, rarity: EnemyRarity): number;
+/**
+ * Get stat multiplier for fractional CR (sub-level enemies).
+ *
+ * Uses a continuous linear ramp from 0.5x at CR 0 to 1.0x at CR 1:
+ * - CR 0.125: ~0.56x
+ * - CR 0.25:  ~0.63x
+ * - CR 0.5:   ~0.75x
+ * - CR 1.0:   1.0x
+ *
+ * Exported so EnemyGenerator can use the same formula.
+ */
+export declare function getFractionalCRStatMultiplier(level: number): number;
+/**
+ * Compute attack stats (damage die, damage modifier, attack bonus) at a given level.
+ *
+ * Current system:
+ * - Damage die: purely rarity-based (d6/d8/d10/d12)
+ * - Damage modifier: hardcoded per rarity (+2/+3/+4/+6)
+ * - Attack bonus: proficiency + ability modifier (but ability modifier is ignored)
+ *
+ * New system:
+ * - Damage die: level-based (d6 → d8 → d10 → d12 → 2d6 → 2d8)
+ * - Damage modifier: actual ability modifier from primary stat + base level bonus
+ * - Attack bonus: proficiency + ability modifier + extra level bonus
+ *
+ * @param baseStats - The scaled ability scores for the enemy
+ * @param level - Effective attack level (1-30+)
+ * @param rarity - Enemy rarity tier
+ * @param archetype - Enemy combat archetype (determines primary stat)
+ * @returns Object with damageDie, damageModifier, and attackBonus
+ */
+export declare function getAttackAtLevel(baseStats: AbilityScores, level: number, rarity: EnemyRarity, archetype: EnemyArchetype): {
+    damageDie: string;
+    damageModifier: number;
+    attackBonus: number;
+};
+/**
+ * Compute AC (defense) at a given level.
+ *
+ * Current system: AC = baseAC + DEX_modifier + equipment_modifier
+ * New system adds level-based AC scaling: AC = baseAC + DEX_modifier + equipment_modifier + levelBonus
+ *
+ * @param baseStats - The scaled ability scores for the enemy
+ * @param level - Effective defense level (1-30+)
+ * @param baseAC - Base AC from enemy template (e.g., 13 for orc)
+ * @param equipment - Equipment configuration (armor, shield)
+ * @returns Computed AC value
+ */
+export declare function getDefenseAtLevel(baseStats: AbilityScores, level: number, baseAC: number, equipment: EquipmentConfig): number;
+/**
+ * Compute the ability modifier that should be used for damage,
+ * replacing the hardcoded rarity-based modifier.
+ *
+ * Uses the actual primary ability score for the archetype:
+ * - Brute: STR modifier
+ * - Archer: DEX modifier
+ * - Support: CHA modifier
+ *
+ * Plus a small base bonus from level scaling.
+ *
+ * @param baseStats - Scaled ability scores
+ * @param level - Effective level
+ * @param archetype - Enemy archetype
+ * @returns Damage modifier to use
+ */
+export declare function getDamageModifierForStats(baseStats: AbilityScores, level: number, archetype: EnemyArchetype): number;
+//# sourceMappingURL=StatScaling.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"StatScaling.d.ts","sourceRoot":"","sources":["../../src/constants/StatScaling.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAChE,OAAO,KAAK,EAAE,WAAW,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAsH3F;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAU3D;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,YAAY,CACxB,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,WAAW,GACpB,MAAM,CAWR;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,6BAA6B,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAInE;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,gBAAgB,CAC5B,SAAS,EAAE,aAAa,EACxB,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,WAAW,EACnB,SAAS,EAAE,cAAc,GAC1B;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,cAAc,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAE,CAmBpE;AAkBD;;;;;;;;;;;GAWG;AACH,wBAAgB,iBAAiB,CAC7B,SAAS,EAAE,aAAa,EACxB,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,eAAe,GAC3B,MAAM,CAmBR;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,yBAAyB,CACrC,SAAS,EAAE,aAAa,EACxB,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,cAAc,GAC1B,MAAM,CAKR"}