rpg-event-generator 1.0.0

package/dist/index.js

@@ -0,0 +1,1144 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.RPGEventGenerator = void 0;
+const {
+  Chance
+} = require('chance');
+class SimpleMarkovGenerator {
+  constructor(options = {}) {
+    this.stateSize = options.stateSize || 2;
+    this.data = [];
+    this.chain = new Map();
+  }
+  addData(texts) {
+    this.data = this.data.concat(texts);
+    this.buildChain();
+  }
+  buildChain() {
+    this.chain.clear();
+    this.data.forEach(text => {
+      const words = text.split(/\s+/);
+      for (let i = 0; i <= words.length - this.stateSize; i++) {
+        const state = words.slice(i, i + this.stateSize).join(' ');
+        const nextWord = words[i + this.stateSize];
+        if (!this.chain.has(state)) {
+          this.chain.set(state, []);
+        }
+        if (nextWord) {
+          this.chain.get(state).push(nextWord);
+        }
+      }
+    });
+  }
+  generate(options = {}) {
+    const minLength = options.minLength || 20;
+    const maxLength = options.maxLength || 100;
+    const maxTries = options.maxTries || 10;
+    for (let tries = 0; tries < maxTries; tries++) {
+      const result = this.generateAttempt(minLength, maxLength);
+      if (result) {
+        return {
+          string: result
+        };
+      }
+    }
+    const fragments = [];
+    const numFragments = Math.floor(Math.random() * 2) + 2;
+    for (let i = 0; i < numFragments; i++) {
+      const fragment = this.data[Math.floor(Math.random() * this.data.length)];
+      if (fragment && !fragments.includes(fragment)) {
+        fragments.push(fragment);
+      }
+    }
+    let combined = fragments.join('. ');
+    if (!combined.endsWith('.')) combined += '.';
+    return {
+      string: combined
+    };
+  }
+  generateAttempt(minLength, maxLength) {
+    const states = Array.from(this.chain.keys());
+    if (states.length === 0) return null;
+    let currentState = states[Math.floor(Math.random() * states.length)];
+    const words = currentState.split(' ');
+    let attempts = 0;
+    const maxAttempts = 100;
+    while (words.join(' ').length < maxLength && attempts < maxAttempts) {
+      const nextWords = this.chain.get(currentState);
+      if (!nextWords || nextWords.length === 0) {
+        const similarStates = states.filter(s => s.split(' ')[0] === words[words.length - 1]);
+        if (similarStates.length > 0) {
+          currentState = similarStates[Math.floor(Math.random() * similarStates.length)];
+          const stateWords = currentState.split(' ');
+          words.push(...stateWords.slice(1));
+        } else {
+          break;
+        }
+      } else {
+        const nextWord = nextWords[Math.floor(Math.random() * nextWords.length)];
+        words.push(nextWord);
+        currentState = words.slice(-this.stateSize).join(' ');
+      }
+      attempts++;
+    }
+    const result = words.join(' ');
+    let finalResult = result.charAt(0).toUpperCase() + result.slice(1);
+    if (!finalResult.endsWith('.') && !finalResult.endsWith('!') && !finalResult.endsWith('?')) {
+      finalResult += '.';
+    }
+    return finalResult.length >= minLength && finalResult.length <= maxLength ? finalResult : null;
+  }
+
+  /**
+   * Check if generated text is interesting enough to use
+   * @private
+   */
+  isInterestingText(text) {
+    const boringWords = ['ordinary', 'normal', 'regular', 'simple', 'plain', 'basic', 'usual', 'typical', 'common', 'standard', 'boring', 'mundane', 'dull'];
+    const interestingWords = ['mysterious', 'ancient', 'powerful', 'dark', 'forbidden', 'legendary', 'cursed', 'magical', 'dramatic', 'intense', 'shadowy', 'forbidding', 'enchanted'];
+    const lowerText = text.toLowerCase();
+    if (boringWords.some(word => lowerText.includes(word))) {
+      return false;
+    }
+    if (interestingWords.some(word => lowerText.includes(word))) {
+      return true;
+    }
+    return text.split(' ').length > 8 && text.length > 60;
+  }
+}
+
+/**
+ * RPG Event Generator - Procedural event generation for RPG games
+ * @class
+ */
+class RPGEventGenerator {
+  /**
+   * Create a new event generator
+   * @param {Object} options - Configuration options
+   * @param {number} options.stateSize - Markov chain state size (default: 2)
+   * @param {Array} options.trainingData - Custom training data for Markov chains
+   */
+  constructor(options = {}) {
+    this.chance = new Chance();
+    this.markovGenerator = new SimpleMarkovGenerator({
+      stateSize: options.stateSize || 2
+    });
+    const defaultTrainingData = options.trainingData || [
+    // Noble Court Intrigue
+    'The royal court is abuzz with whispers of scandal and betrayal', 'A noble lord approaches you with a proposition that could change your destiny', 'Court politics have reached a fever pitch as alliances shift like desert sands', 'The king\'s advisors plot in shadowed corners while the court dances obliviously', 'A mysterious letter arrives sealed with wax from a noble house you don\'t recognize',
+    // Criminal Underworld
+    'The thieves\' guild has put out a contract that bears your name', 'Shadowy figures lurk in alleyways, watching your every move', 'The black market thrives under the cover of night, offering forbidden luxuries', 'A notorious crime lord has taken an interest in your activities', 'Corrupt guards demand tribute while turning a blind eye to greater crimes',
+    // Supernatural & Mysterious
+    'Strange runes appear on your bedroom wall, glowing with ethereal light', 'An ancient prophecy speaks of a hero who matches your description exactly', 'Ghostly apparitions warn of impending doom in fevered dreams', 'A witch in the woods offers you power beyond mortal comprehension', 'Cursed artifacts surface in the market, promising great power at terrible cost',
+    // Personal & Dramatic
+    'Your past sins come back to haunt you in the most unexpected ways', 'A long-lost relative appears with a tale that shakes your world', 'Your reputation draws admirers and enemies in equal measure', 'A betrayal cuts deeper than any blade, leaving scars on your soul', 'Love and ambition war within your heart as opportunities arise',
+    // Adventure & Exploration
+    'Ancient ruins whisper secrets to those brave enough to listen', 'A dragon\'s hoard lies hidden, protected by trials and tribulations', 'Bandits rule the roads, but their leader seems oddly familiar', 'A legendary artifact calls to you from across distant lands', 'The wilderness holds both peril and promise for the bold adventurer',
+    // Social & Relationship
+    'Romantic entanglements complicate your carefully laid plans', 'Old friends become new enemies as loyalties are tested', 'Family secrets emerge that threaten to destroy everything you hold dear', 'Mentors offer wisdom that comes with strings attached', 'Rivals emerge from unexpected places, challenging your hard-won position',
+    // Economic & Mercantile
+    'The market crashes send shockwaves through the merchant class', 'A get-rich-quick scheme promises fortunes but demands your soul', 'Trade wars erupt between rival merchant houses', 'Investment opportunities arise that could make or break your fortune', 'Black market deals offer power but carry the weight of damnation',
+    // Military & Combat
+    'War drums beat as kingdoms prepare for inevitable conflict', 'Desertion offers freedom but brands you a coward forever', 'A duel of honor is proposed, with your reputation on the line', 'Mercenary companies seek captains brave enough to lead them', 'Battle scars tell stories of glory and horror in equal measure',
+    // Magical & Mystical
+    'The veil between worlds thins, allowing magic to seep into reality', 'Curses and blessings intertwine in ways you never expected', 'Ancient bloodlines awaken powers dormant for generations', 'Rituals performed in secret grant power at terrible personal cost', 'The stars themselves seem to conspire in your favor or against you',
+    // Seasonal & Natural
+    'Winter\'s cruel bite forces desperate measures from the populace', 'Spring\'s renewal brings both hope and dangerous new beginnings', 'Summer tournaments test the mettle of warriors and nobles alike', 'Autumn harvests reveal secrets long buried in the fields', 'The changing seasons mirror the turmoil in your own life',
+    // Dramatic Twists
+    'What seems like a blessing reveals itself as a curse in disguise', 'Enemies become allies, and allies become your greatest threat', 'The path of righteousness leads to ruin, while villainy brings reward', 'Fate itself seems to take notice of your actions, for good or ill', 'The world bends around you as your choices reshape reality itself'];
+    try {
+      this.markovGenerator.addData(defaultTrainingData);
+    } catch (error) {
+      console.warn('Markov generator training failed:', error.message);
+    }
+    this.templates = {
+      COURT_SCANDAL: {
+        title: 'Court Scandal',
+        narrative: 'Whispers of infidelity and betrayal rock the royal court, threatening to expose secrets that could topple kingdoms.',
+        choices: [{
+          text: 'Exploit the scandal for personal gain',
+          effect: {
+            influence: [15, 30],
+            reputation: [-10, -5],
+            karma: [-10, -5]
+          },
+          consequence: 'court_manipulator'
+        }, {
+          text: 'Help contain the scandal',
+          effect: {
+            influence: [5, 15],
+            reputation: [10, 20],
+            favor: 'royal'
+          },
+          consequence: 'court_ally'
+        }, {
+          text: 'Remain neutral and observe',
+          effect: {
+            influence: [0, 5]
+          },
+          consequence: 'court_observer'
+        }]
+      },
+      NOBLE_DUEL: {
+        title: 'Challenge of Honor',
+        narrative: 'A noble of considerable standing has insulted your honor and demands satisfaction through single combat.',
+        choices: [{
+          text: 'Accept the duel immediately',
+          effect: {
+            reputation: [20, 40],
+            health: [-20, -5]
+          },
+          requirements: {
+            combat_skill: 50
+          },
+          consequence: 'duelist'
+        }, {
+          text: 'Demand a champion fight in your stead',
+          effect: {
+            gold: [-200, -100],
+            reputation: [5, 15]
+          },
+          consequence: 'strategist'
+        }, {
+          text: 'Apologize and offer compensation',
+          effect: {
+            gold: [-500, -200],
+            reputation: [-15, -5]
+          },
+          consequence: 'diplomat'
+        }]
+      },
+      THIEVES_GUILD: {
+        title: 'Shadows Call',
+        narrative: 'The thieves\' guild has noticed your growing influence and extends an invitation to join their ranks.',
+        choices: [{
+          text: 'Accept their offer',
+          effect: {
+            gold: [100, 300],
+            underworld_contacts: true
+          },
+          consequence: 'guild_member'
+        }, {
+          text: 'Negotiate better terms',
+          effect: {
+            influence: [10, 25],
+            negotiation_success: [0.6, 0.9]
+          },
+          consequence: 'guild_negotiator'
+        }, {
+          text: 'Reject them firmly',
+          effect: {
+            reputation: [5, 15],
+            underworld_enemies: true
+          },
+          consequence: 'guild_enemy'
+        }]
+      },
+      BLACKMAIL_OPPORTUNITY: {
+        title: 'Compromising Evidence',
+        narrative: 'You\'ve discovered evidence that could ruin a powerful figure. How you handle this will define your character.',
+        choices: [{
+          text: 'Use it for blackmail',
+          effect: {
+            gold: [500, 1500],
+            reputation: [-20, -10],
+            karma: [-20, -10]
+          },
+          consequence: 'blackmailer'
+        }, {
+          text: 'Destroy the evidence',
+          effect: {
+            reputation: [15, 30],
+            karma: [10, 20]
+          },
+          consequence: 'honorable'
+        }, {
+          text: 'Sell it to the highest bidder',
+          effect: {
+            gold: [200, 800],
+            underworld_contacts: true
+          },
+          consequence: 'information_broker'
+        }]
+      },
+      ANCIENT_CURSE: {
+        title: 'Ancient Curse Awakens',
+        narrative: 'An ancient artifact you touched has awakened a curse that now plagues your dreams and waking hours.',
+        choices: [{
+          text: 'Seek a priest\'s blessing',
+          effect: {
+            gold: [-100, -50],
+            health: [10, 25],
+            faith: [10, 20]
+          },
+          consequence: 'blessed'
+        }, {
+          text: 'Consult a witch or sorcerer',
+          effect: {
+            gold: [-300, -100],
+            curse_lifted: [0.4, 0.7]
+          },
+          consequence: 'occultist'
+        }, {
+          text: 'Endure the curse\'s effects',
+          effect: {
+            health: [-15, -5],
+            stress: [10, 25]
+          },
+          consequence: 'cursed'
+        }]
+      },
+      GHOSTLY_VISITATION: {
+        title: 'Spirit from the Past',
+        narrative: 'The ghost of someone from your past appears, demanding justice or offering redemption.',
+        choices: [{
+          text: 'Help the spirit find peace',
+          effect: {
+            karma: [15, 30],
+            stress: [5, 15]
+          },
+          consequence: 'redeemer'
+        }, {
+          text: 'Demand answers from the spirit',
+          effect: {
+            knowledge: [10, 25],
+            stress: [10, 20]
+          },
+          consequence: 'truth_seeker'
+        }, {
+          text: 'Banish the spirit forcefully',
+          effect: {
+            karma: [-10, -5],
+            stress: [15, 25]
+          },
+          consequence: 'spirit_banisher'
+        }]
+      },
+      FORBIDDEN_LOVE: {
+        title: 'Forbidden Romance',
+        narrative: 'Your heart has been captured by someone utterly unsuitable - a married noble, a sworn enemy, or someone from a forbidden class.',
+        choices: [{
+          text: 'Pursue the romance secretly',
+          effect: {
+            happiness: [20, 40],
+            stress: [10, 25],
+            scandal_risk: [0.3, 0.7]
+          },
+          consequence: 'secret_lover'
+        }, {
+          text: 'End it before it begins',
+          effect: {
+            happiness: [-10, -5],
+            reputation: [5, 10]
+          },
+          consequence: 'disciplined'
+        }, {
+          text: 'Confess everything publicly',
+          effect: {
+            reputation: [-30, -10],
+            influence: [-15, -5],
+            drama: true
+          },
+          consequence: 'dramatic'
+        }]
+      },
+      FAMILY_SECRET: {
+        title: 'Family Secret Revealed',
+        narrative: 'A shocking family secret emerges that could destroy your lineage or elevate it to legendary status.',
+        choices: [{
+          text: 'Embrace the secret and use it',
+          effect: {
+            influence: [20, 40],
+            family_legacy: true
+          },
+          consequence: 'ambitious'
+        }, {
+          text: 'Hide the secret at all costs',
+          effect: {
+            gold: [-500, -200],
+            stress: [15, 30]
+          },
+          consequence: 'protector'
+        }, {
+          text: 'Reveal it to the world',
+          effect: {
+            reputation: [-25, 5],
+            influence: [10, 30]
+          },
+          consequence: 'truthful'
+        }]
+      },
+      LOST_CIVILIZATION: {
+        title: 'Lost Civilization Discovered',
+        narrative: 'Your explorations have led to the ruins of an ancient civilization, filled with treasures and dangers.',
+        choices: [{
+          text: 'Loot everything you can carry',
+          effect: {
+            gold: [1000, 3000],
+            health: [-10, -30],
+            cursed_item: [0.2, 0.5]
+          },
+          consequence: 'treasure_hunter'
+        }, {
+          text: 'Study the artifacts carefully',
+          effect: {
+            knowledge: [20, 40],
+            influence: [10, 25]
+          },
+          consequence: 'archaeologist'
+        }, {
+          text: 'Leave the site undisturbed',
+          effect: {
+            karma: [10, 20],
+            reputation: [5, 15]
+          },
+          consequence: 'preserver'
+        }]
+      },
+      BANDIT_KING: {
+        title: 'Bandit King\'s Challenge',
+        narrative: 'The infamous bandit king blocks your path, offering you a choice: join his band or face certain death.',
+        choices: [{
+          text: 'Join the bandits',
+          effect: {
+            gold: [200, 500],
+            reputation: [-30, -15],
+            combat_skill: [5, 15]
+          },
+          consequence: 'bandit'
+        }, {
+          text: 'Challenge him to single combat',
+          effect: {
+            reputation: [20, 40],
+            health: [-30, -10]
+          },
+          requirements: {
+            combat_skill: 60
+          },
+          consequence: 'hero'
+        }, {
+          text: 'Bribe your way past',
+          effect: {
+            gold: [-400, -200],
+            safe_passage: true
+          },
+          consequence: 'diplomat'
+        }]
+      },
+      MARKET_CRASH: {
+        title: 'Market Catastrophe',
+        narrative: 'A sudden market crash threatens to wipe out fortunes across the kingdom, including your own investments.',
+        choices: [{
+          text: 'Sell everything immediately',
+          effect: {
+            gold: [-30, -10],
+            market_recovery: true
+          },
+          consequence: 'cautious_trader'
+        }, {
+          text: 'Buy up distressed assets',
+          effect: {
+            gold: [-1000, 2000],
+            risk: [0.4, 0.8]
+          },
+          consequence: 'speculator'
+        }, {
+          text: 'Hold and weather the storm',
+          effect: {
+            gold: [-50, 50],
+            reputation: [10, 20]
+          },
+          consequence: 'patient_investor'
+        }]
+      },
+      TRADE_WAR: {
+        title: 'Trade War Escalates',
+        narrative: 'Rival merchant houses have declared economic warfare, and you\'re caught in the middle.',
+        choices: [{
+          text: 'Form an alliance with one side',
+          effect: {
+            influence: [15, 30],
+            gold: [200, 600]
+          },
+          consequence: 'alliance_builder'
+        }, {
+          text: 'Play both sides against each other',
+          effect: {
+            gold: [500, 1500],
+            reputation: [-15, -5]
+          },
+          consequence: 'manipulator'
+        }, {
+          text: 'Stay neutral and wait it out',
+          effect: {
+            gold: [-100, 0],
+            reputation: [5, 15]
+          },
+          consequence: 'neutral_party'
+        }]
+      },
+      DESERTION_TEMPTATION: {
+        title: 'Cowardice or Wisdom?',
+        narrative: 'Your commanding officer leads your unit into certain slaughter. Desertion offers survival, but at the cost of honor.',
+        choices: [{
+          text: 'Desert and save yourself',
+          effect: {
+            health: [0, 10],
+            reputation: [-40, -20],
+            stress: [20, 40]
+          },
+          consequence: 'deserter'
+        }, {
+          text: 'Lead a mutiny against the commander',
+          effect: {
+            influence: [30, 60],
+            reputation: [-20, 10]
+          },
+          consequence: 'mutineer'
+        }, {
+          text: 'Stand and fight with honor',
+          effect: {
+            reputation: [20, 40],
+            health: [-40, -20]
+          },
+          consequence: 'hero'
+        }]
+      },
+      MERCENARY_CONTRACT: {
+        title: 'Lucrative but Dangerous',
+        narrative: 'A wealthy patron offers you a mercenary contract that promises great wealth but involves fighting against impossible odds.',
+        choices: [{
+          text: 'Accept the contract',
+          effect: {
+            gold: [1000, 3000],
+            health: [-30, -10],
+            reputation: [10, 30]
+          },
+          consequence: 'mercenary'
+        }, {
+          text: 'Negotiate better terms',
+          effect: {
+            gold: [800, 2000],
+            influence: [10, 25]
+          },
+          consequence: 'negotiator'
+        }, {
+          text: 'Decline the offer',
+          effect: {
+            reputation: [5, 15]
+          },
+          consequence: 'prudent'
+        }]
+      }
+    };
+  }
+
+  /**
+   * Generate a rich, contextual event based on player state
+   * @param {Object} playerContext - Player stats and state
+   * @returns {Object} Generated event with deep narrative
+   */
+  generateEvent(playerContext = {}) {
+    const context = this.analyzeContext(playerContext);
+    const template = this.selectTemplate(context);
+    return {
+      id: `event_${Date.now()}_${this.chance.guid().substring(0, 8)}`,
+      title: this.generateDynamicTitle(template, context),
+      description: this.generateRichDescription(template, context),
+      narrative: template.narrative,
+      choices: this.generateContextualChoices(template.choices, context),
+      type: Object.keys(this.templates).find(key => this.templates[key] === template),
+      consequence: null,
+      context: context,
+      urgency: this.calculateUrgency(template, context),
+      theme: this.determineTheme(template, context)
+    };
+  }
+
+  /**
+   * Generate multiple events at once
+   * @param {Object} playerContext - Player stats and state
+   * @param {number} count - Number of events to generate
+   * @returns {Array} Array of generated events
+   */
+  generateEvents(playerContext = {}, count = 1) {
+    const events = [];
+    for (let i = 0; i < count; i++) {
+      events.push(this.generateEvent(playerContext));
+    }
+    return events;
+  }
+
+  /**
+   * Analyze and enrich player context for sophisticated event generation
+   * @private
+   */
+  analyzeContext(playerContext) {
+    // Handle null or undefined playerContext
+    const ctx = playerContext || {};
+    const context = {
+      age: ctx.age || 16,
+      wealth: ctx.gold || 0,
+      influence: ctx.influence || 0,
+      reputation: ctx.reputation || 0,
+      career: ctx.career || null,
+      skills: ctx.skills || {},
+      relationships: ctx.relationships || [],
+      location: ctx.location || this.generateLocation(),
+      season: ctx.season || 'spring',
+      health: ctx.health || 100,
+      stress: ctx.stress || 0,
+      happiness: ctx.happiness || 50,
+      karma: ctx.karma || 0,
+      faith: ctx.faith || 0,
+      vices: ctx.vices || [],
+      secrets: ctx.secrets || [],
+      ambitions: ctx.ambitions || []
+    };
+    context.social_standing = this.calculateSocialStanding(context);
+    context.power_level = this.calculatePowerLevel(context);
+    context.life_experience = this.calculateLifeExperience(context);
+    return context;
+  }
+
+  /**
+   * Calculate social standing based on various factors
+   * @private
+   */
+  calculateSocialStanding(context) {
+    let standing = 0;
+    standing += context.influence * 0.4;
+    standing += context.reputation * 0.3;
+    standing += context.wealth / 100 * 0.3;
+    if (context.career && context.career.toLowerCase().includes('noble')) {
+      standing += 20;
+    }
+    return Math.max(0, Math.min(100, standing));
+  }
+
+  /**
+   * Calculate overall power level
+   * @private
+   */
+  calculatePowerLevel(context) {
+    let power = 0;
+    power += context.influence * 0.3;
+    power += context.wealth / 100 * 0.2;
+    power += Object.values(context.skills).reduce((sum, skill) => sum + skill, 0) / 10 * 0.2;
+    power += context.relationships.length * 5 * 0.1;
+    power += (100 - context.stress) * 0.2;
+    return Math.max(0, power);
+  }
+
+  /**
+   * Calculate life experience factor
+   * @private
+   */
+  calculateLifeExperience(context) {
+    let experience = context.age * 0.5;
+    experience += Object.values(context.skills).reduce((sum, skill) => sum + skill, 0) * 0.1;
+    experience += context.relationships.length * 2;
+    experience += context.ambitions.length * 3;
+    return experience;
+  }
+
+  /**
+   * Generate a random location for context
+   * @private
+   */
+  generateLocation() {
+    const locations = ['capital', 'border town', 'coastal city', 'mountain village', 'forest outpost', 'desert caravan stop', 'riverside settlement', 'island fortress', 'underground city', 'floating market'];
+    return this.chance.pickone(locations);
+  }
+
+  /**
+   * Select the most appropriate template based on rich context analysis
+   * @private
+   */
+  selectTemplate(context) {
+    const templateKeys = Object.keys(this.templates);
+    const weights = this.calculateTemplateWeights(context, templateKeys);
+    const selectedKey = this.chance.weighted(templateKeys, weights);
+    return this.templates[selectedKey];
+  }
+
+  /**
+   * Calculate dynamic weights for template selection based on context
+   * @private
+   */
+  calculateTemplateWeights(context, templateKeys) {
+    const baseWeights = {};
+    templateKeys.forEach(key => {
+      const template = this.templates[key];
+      baseWeights[key] = this.getBaseWeightForTemplate(key, context);
+    });
+    this.applyContextModifiers(baseWeights, context);
+    const totalWeight = Object.values(baseWeights).reduce((sum, w) => sum + w, 0);
+    const normalizedWeights = Object.values(baseWeights).map(w => w / totalWeight);
+    return normalizedWeights;
+  }
+
+  /**
+   * Get base weight for a template type
+   * @private
+   */
+  getBaseWeightForTemplate(templateKey, context) {
+    const weights = {
+      COURT_SCANDAL: 0.08,
+      NOBLE_DUEL: 0.06,
+      THIEVES_GUILD: 0.07,
+      BLACKMAIL_OPPORTUNITY: 0.05,
+      ANCIENT_CURSE: 0.04,
+      GHOSTLY_VISITATION: 0.03,
+      FORBIDDEN_LOVE: 0.06,
+      FAMILY_SECRET: 0.04,
+      LOST_CIVILIZATION: 0.05,
+      BANDIT_KING: 0.07,
+      MARKET_CRASH: 0.06,
+      TRADE_WAR: 0.05,
+      DESERTION_TEMPTATION: 0.03,
+      MERCENARY_CONTRACT: 0.04
+    };
+    return weights[templateKey] || 0.05;
+  }
+
+  /**
+   * Apply context-based modifiers to template weights
+   * @private
+   */
+  applyContextModifiers(weights, context) {
+    if (context.career) {
+      const career = context.career.toLowerCase();
+      if (career.includes('noble') || career.includes('court')) {
+        weights.COURT_SCANDAL *= 2.5;
+        weights.NOBLE_DUEL *= 2.0;
+        weights.FORBIDDEN_LOVE *= 1.8;
+      }
+      if (career.includes('merchant') || career.includes('trade')) {
+        weights.MARKET_CRASH *= 2.2;
+        weights.TRADE_WAR *= 2.0;
+        weights.BLACKMAIL_OPPORTUNITY *= 1.5;
+      }
+      if (career.includes('thief') || career.includes('criminal')) {
+        weights.THIEVES_GUILD *= 2.5;
+        weights.BLACKMAIL_OPPORTUNITY *= 2.0;
+      }
+      if (career.includes('warrior') || career.includes('knight')) {
+        weights.NOBLE_DUEL *= 2.2;
+        weights.MERCENARY_CONTRACT *= 1.8;
+        weights.DESERTION_TEMPTATION *= 1.5;
+      }
+    }
+
+    // Age-based modifiers
+    if (context.age < 25) {
+      weights.FORBIDDEN_LOVE *= 1.6;
+      weights.FAMILY_SECRET *= 1.4;
+    } else if (context.age > 50) {
+      weights.GHOSTLY_VISITATION *= 1.8;
+      weights.FAMILY_SECRET *= 1.6;
+    }
+
+    // Wealth-based modifiers
+    if (context.wealth > 1000) {
+      weights.MARKET_CRASH *= 1.8;
+      weights.TRADE_WAR *= 1.6;
+      weights.BLACKMAIL_OPPORTUNITY *= 1.4;
+    }
+
+    // Influence-based modifiers
+    if (context.influence > 50) {
+      weights.COURT_SCANDAL *= 2.0;
+      weights.NOBLE_DUEL *= 1.8;
+    }
+
+    // Skill-based modifiers
+    if (context.skills.combat > 60) {
+      weights.NOBLE_DUEL *= 1.6;
+      weights.MERCENARY_CONTRACT *= 1.4;
+    }
+    if (context.skills.diplomacy > 60) {
+      weights.COURT_SCANDAL *= 1.5;
+      weights.FORBIDDEN_LOVE *= 1.3;
+    }
+    if (context.skills.thievery > 60) {
+      weights.THIEVES_GUILD *= 1.7;
+      weights.BLACKMAIL_OPPORTUNITY *= 1.5;
+    }
+
+    // Reputation-based modifiers
+    if (context.reputation < -20) {
+      weights.THIEVES_GUILD *= 1.8;
+      weights.BLACKMAIL_OPPORTUNITY *= 2.0;
+    }
+
+    // Relationship-based modifiers
+    if (context.relationships && context.relationships.length > 3) {
+      weights.FORBIDDEN_LOVE *= 1.4;
+      weights.FAMILY_SECRET *= 1.6;
+      weights.COURT_SCANDAL *= 1.3;
+    }
+
+    // Seasonal modifiers
+    if (context.season === 'winter') {
+      weights.GHOSTLY_VISITATION *= 1.5;
+      weights.ANCIENT_CURSE *= 1.3;
+    }
+  }
+
+  /**
+   * Generate dynamic, context-aware title
+   * @private
+   */
+  generateDynamicTitle(template, context) {
+    const titleModifiers = {
+      dramatic: ['Shocking', 'Unbelievable', 'Extraordinary', 'Monumental'],
+      urgent: ['Critical', 'Immediate', 'Pressing', 'Urgent'],
+      mysterious: ['Enigmatic', 'Puzzling', 'Curious', 'Intriguing'],
+      personal: ['Intimate', 'Personal', 'Private', 'Close'],
+      dangerous: ['Perilous', 'Dangerous', 'Risky', 'Treacherous']
+    };
+    let modifierType = 'dramatic';
+    const templateKey = Object.keys(this.templates).find(key => this.templates[key] === template);
+    if (templateKey.includes('SCANDAL') || templateKey.includes('DUEL') || templateKey.includes('CRASH')) {
+      modifierType = 'urgent';
+    } else if (templateKey.includes('CURSE') || templateKey.includes('GHOST') || templateKey.includes('SECRET')) {
+      modifierType = 'mysterious';
+    } else if (templateKey.includes('LOVE') || templateKey.includes('FAMILY')) {
+      modifierType = 'personal';
+    } else if (templateKey.includes('BANDIT') || templateKey.includes('DESERTION') || templateKey.includes('MERCENARY')) {
+      modifierType = 'dangerous';
+    }
+    const modifier = this.chance.pickone(titleModifiers[modifierType]);
+    return `${modifier} ${template.title}`;
+  }
+
+  /**
+   * Generate rich, contextual description with personality
+   * @private
+   */
+  generateRichDescription(template, context) {
+    try {
+      let description = template.narrative;
+      const generated = this.markovGenerator.generate({
+        minLength: 30,
+        maxLength: 80,
+        allowDuplicates: false,
+        maxTries: 5
+      });
+      if (generated && generated.string && generated.string.length > 40 && generated.string.split(' ').length > 6 && !this.data.some(training => training === generated.string) && this.isInterestingText(generated.string)) {
+        description = generated.string + '. ' + description.charAt(0).toLowerCase() + description.slice(1);
+      }
+      const contextAdditions = this.generateContextAdditions(template, context);
+      if (contextAdditions.length > 0) {
+        description += ' ' + this.chance.pickone(contextAdditions);
+      }
+      if (this.chance.bool({
+        likelihood: 40
+      })) {
+        const consequenceHint = this.generateConsequenceHint(template, context);
+        if (consequenceHint) {
+          description += ' ' + consequenceHint;
+        }
+      }
+      return description;
+    } catch (error) {
+      return template.narrative;
+    }
+  }
+
+  /**
+   * Generate contextual additions to descriptions
+   * @private
+   */
+  generateContextAdditions(template, context) {
+    const additions = [];
+    if (context.career) {
+      const career = context.career.toLowerCase();
+      if (career.includes('noble') || career.includes('court')) {
+        additions.push('Your position in court makes this matter particularly sensitive.');
+        additions.push('The royal family\'s involvement complicates everything.');
+      }
+      if (career.includes('merchant')) {
+        additions.push('Your business interests are directly affected by this development.');
+        additions.push('The merchant guilds are already positioning themselves.');
+      }
+      if (career.includes('warrior') || career.includes('knight')) {
+        additions.push('Your martial prowess could turn the tide of this situation.');
+        additions.push('The battlefield calls, and honor demands a response.');
+      }
+    }
+
+    // Age-based additions
+    if (context.age < 25) {
+      additions.push('At your young age, this experience could shape your entire future.');
+    } else if (context.age > 60) {
+      additions.push('With age comes wisdom, but also the weight of past decisions.');
+    }
+
+    // Relationship-based additions
+    if (context.relationships && context.relationships.length > 0) {
+      additions.push('Your personal connections may influence how this unfolds.');
+      additions.push('Someone you know is intimately involved in this matter.');
+    }
+
+    // Seasonal additions
+    if (context.season) {
+      const seasonAdditions = {
+        winter: 'The harsh winter weather makes resolution all the more urgent.',
+        spring: 'Spring\'s renewal brings hope, but also unpredictable change.',
+        summer: 'Summer\'s heat mirrors the intensity of the situation.',
+        autumn: 'Autumn\'s harvest season reminds us that all things must end.'
+      };
+      if (seasonAdditions[context.season]) {
+        additions.push(seasonAdditions[context.season]);
+      }
+    }
+    return additions;
+  }
+
+  /**
+   * Generate subtle hints about potential consequences
+   * @private
+   */
+  generateConsequenceHint(template, context) {
+    const hints = ['The choices you make here will echo through your future.', 'This decision carries weight beyond what you can immediately see.', 'Your response will define how others perceive you.', 'The consequences of this moment will be felt for years to come.', 'Choose wisely, for the wrong path leads to ruin.', 'This crossroads will determine your destiny.'];
+    const hintChance = Math.min(0.4, (context.influence + Math.abs(context.reputation)) / 200);
+    if (this.chance.bool({
+      likelihood: hintChance * 100
+    })) {
+      return this.chance.pickone(hints);
+    }
+    return null;
+  }
+
+  /**
+   * Generate choices that adapt to player context and have meaningful consequences
+   * @private
+   */
+  generateContextualChoices(templateChoices, context) {
+    return templateChoices.map(choice => {
+      const resolvedChoice = {
+        ...choice
+      };
+      resolvedChoice.effect = this.resolveEffects(choice.effect, context);
+      resolvedChoice.text = this.enhanceChoiceText(choice.text, context);
+      if (choice.consequence) {
+        resolvedChoice.consequence = choice.consequence;
+      }
+      return resolvedChoice;
+    });
+  }
+
+  /**
+   * Resolve effect ranges to specific values based on context
+   * @private
+   */
+  resolveEffects(effectRanges, context) {
+    const resolved = {};
+    Object.entries(effectRanges).forEach(([key, value]) => {
+      if (Array.isArray(value)) {
+        let min = value[0];
+        let max = value[1];
+        const multiplier = this.getContextMultiplier(key, context);
+        min = Math.round(min * multiplier);
+        max = Math.round(max * multiplier);
+        if (min > max) {
+          [min, max] = [max, min];
+        }
+        resolved[key] = this.chance.integer({
+          min,
+          max
+        });
+      } else if (typeof value === 'number') {
+        resolved[key] = value;
+      } else {
+        resolved[key] = value;
+      }
+    });
+    return resolved;
+  }
+
+  /**
+   * Get context multiplier for effects
+   * @private
+   */
+  getContextMultiplier(effectKey, context) {
+    let multiplier = 1.0;
+    switch (effectKey) {
+      case 'influence':
+      case 'reputation':
+        if (context.influence > 30) multiplier *= 1.2;
+        if (context.reputation > 20) multiplier *= 1.1;
+        break;
+      case 'gold':
+        if (context.wealth > 500) multiplier *= 1.3;
+        if (context.wealth < 100) multiplier *= 0.8;
+        break;
+      case 'health':
+        break;
+      case 'stress':
+      case 'happiness':
+        if (context.age > 40) multiplier *= 1.1; // More emotional impact with age
+        break;
+    }
+    return multiplier;
+  }
+
+  /**
+   * Enhance choice text with contextual details
+   * @private
+   */
+  enhanceChoiceText(baseText, context) {
+    const enhancements = [];
+    if (context.career && this.chance.bool({
+      likelihood: 20
+    })) {
+      const career = context.career.toLowerCase();
+      if (career.includes('noble')) {
+        enhancements.push(' (with noble dignity)');
+      } else if (career.includes('merchant')) {
+        enhancements.push(' (calculating the profits)');
+      } else if (career.includes('warrior')) {
+        enhancements.push(' (with martial resolve)');
+      }
+    }
+    if (enhancements.length > 0) {
+      return baseText + this.chance.pickone(enhancements);
+    }
+    return baseText;
+  }
+
+  /**
+   * Calculate event urgency based on template and context
+   * @private
+   */
+  calculateUrgency(template, context) {
+    let urgency = 'normal';
+    if (template.title.toLowerCase().includes('critical') || template.title.toLowerCase().includes('urgent') || template.narrative.toLowerCase().includes('immediately')) {
+      urgency = 'high';
+    }
+    if (context.health < 30 || context.wealth < 50) {
+      urgency = 'high';
+    }
+    if (context.influence > 70) {
+      urgency = 'high';
+    }
+    return urgency;
+  }
+
+  /**
+   * Determine the thematic category of the event
+   * @private
+   */
+  determineTheme(template, context) {
+    const templateKey = Object.keys(this.templates).find(key => this.templates[key] === template);
+    if (templateKey.includes('COURT') || templateKey.includes('NOBLE')) {
+      return 'political';
+    } else if (templateKey.includes('THIEF') || templateKey.includes('BLACKMAIL')) {
+      return 'criminal';
+    } else if (templateKey.includes('CURSE') || templateKey.includes('GHOST')) {
+      return 'supernatural';
+    } else if (templateKey.includes('LOVE') || templateKey.includes('FAMILY')) {
+      return 'personal';
+    } else if (templateKey.includes('CIVILIZATION') || templateKey.includes('BANDIT')) {
+      return 'adventure';
+    } else if (templateKey.includes('MARKET') || templateKey.includes('TRADE')) {
+      return 'economic';
+    } else if (templateKey.includes('DESERTION') || templateKey.includes('MERCENARY')) {
+      return 'military';
+    }
+    return 'general';
+  }
+
+  /**
+   * Generate contextual choices with resolved effects
+   * @private
+   */
+  generateChoices(baseChoices, context) {
+    return baseChoices.map(choice => ({
+      ...choice,
+      effect: this.resolveEffect(choice.effect, context)
+    }));
+  }
+
+  /**
+   * Resolve dynamic effects (ranges become specific numbers)
+   * @private
+   */
+  resolveEffect(effect, context) {
+    const resolved = {};
+    Object.entries(effect).forEach(([key, value]) => {
+      if (Array.isArray(value)) {
+        resolved[key] = this.chance.integer({
+          min: value[0],
+          max: value[1]
+        });
+      } else {
+        resolved[key] = value;
+      }
+    });
+    if (context.wealth >= 1000 && resolved.gold > 0) {
+      resolved.gold = Math.floor(resolved.gold * 1.5);
+    }
+    return resolved;
+  }
+
+  /**
+   * Generate a random location
+   * @private
+   */
+  generateLocation() {
+    const locations = ['village', 'town', 'city', 'castle', 'forest', 'mountains', 'coast', 'desert'];
+    return this.chance.pickone(locations);
+  }
+
+  /**
+   * Get fallback description if Markov generation fails
+   * @private
+   */
+  getFallbackDescription(templateType) {
+    const fallbacks = {
+      ENCOUNTER: `A ${faker.person.jobTitle()} approaches you with an unusual proposition.`,
+      OPPORTUNITY: `A rare ${faker.commerce.product()} has become available at an exceptional price.`,
+      CHALLENGE: `A ${faker.person.jobTitle()} challenges your position in the community.`,
+      MYSTERY: `Strange occurrences have been reported near ${faker.location.city()}.`
+    };
+    return fallbacks[templateType] || fallbacks.ENCOUNTER;
+  }
+
+  /**
+   * Add custom training data for Markov generation
+   * @param {Array} data - Array of strings to train on
+   */
+  addTrainingData(data) {
+    try {
+      this.markovGenerator.addData(data);
+    } catch (error) {
+      console.warn('Failed to add training data:', error.message);
+    }
+  }
+
+  /**
+   * Reset the Markov generator with new data
+   * @param {Array} data - Array of strings to train on
+   */
+  resetTrainingData(data) {
+    this.markovGenerator = new SimpleMarkovGenerator({
+      stateSize: 2
+    });
+    this.addTrainingData(data);
+  }
+}
+exports.RPGEventGenerator = RPGEventGenerator;
+function generateRPGEvent(playerContext = {}) {
+  const generator = new RPGEventGenerator();
+  return generator.generateEvent(playerContext);
+}
+module.exports = {
+  RPGEventGenerator: RPGEventGenerator,
+  generateRPGEvent: generateRPGEvent
+};