rpg-event-generator 1.0.0 → 1.1.0

package/dist/index.js

@@ -120,35 +120,56 @@ class RPGEventGenerator {
    * @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
+   * @param {string} options.theme - Theme for event generation: 'fantasy', 'sci-fi', 'historical'
+   * @param {string} options.culture - Cultural context within theme (optional)
    */
   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'];
+    this.theme = options.theme || 'fantasy';
+    this.culture = options.culture;
+    this.customTemplates = new Set();
+    this.customChains = new Set();
+    this.customTrainingData = {};
+    this.initializeThemes();
+    this.activeChains = new Map();
+    this.chainDefinitions = this.initializeChainDefinitions();
+    this.difficultySettings = {
+      easy: {
+        powerRange: [0, 50],
+        rewardMultiplier: 1.5,
+        penaltyMultiplier: 0.7
+      },
+      normal: {
+        powerRange: [25, 150],
+        rewardMultiplier: 1.0,
+        penaltyMultiplier: 1.0
+      },
+      hard: {
+        powerRange: [100, 300],
+        rewardMultiplier: 0.8,
+        penaltyMultiplier: 1.3
+      },
+      legendary: {
+        powerRange: [250, 1000],
+        rewardMultiplier: 0.6,
+        penaltyMultiplier: 1.6
+      }
+    };
+
+    // Initialize time system
+    this.timeSystem = {
+      currentDay: 1,
+      currentSeason: 'spring',
+      gameYear: 1,
+      timeBasedEvents: new Map()
+    };
+    const selectedTheme = options.theme || 'fantasy';
+    const selectedCulture = options.culture;
+    const themeTrainingData = this.getThemeTrainingData(selectedTheme, selectedCulture);
+    const defaultTrainingData = options.trainingData || themeTrainingData;
     try {
       this.markovGenerator.addData(defaultTrainingData);
     } catch (error) {
@@ -532,6 +553,370 @@ class RPGEventGenerator {
           },
           consequence: 'prudent'
         }]
+      },
+      // Event Chain Templates
+      BANDIT_AMBUSH: {
+        title: 'Bandit Ambush',
+        narrative: 'A small group of bandits springs an ambush on your caravan, demanding tribute or blood.',
+        choices: [{
+          text: 'Fight back fiercely',
+          effect: {
+            health: [-20, -5],
+            reputation: [10, 25]
+          },
+          consequence: 'hero'
+        }, {
+          text: 'Pay the tribute',
+          effect: {
+            gold: [-200, -50],
+            reputation: [-10, -5]
+          },
+          consequence: 'prudent'
+        }, {
+          text: 'Join the bandits',
+          effect: {
+            reputation: [-20, -10],
+            combat_skill: [5, 10]
+          },
+          consequence: 'bandit'
+        }]
+      },
+      BANDIT_ARMY: {
+        title: 'Bandit Army Assembles',
+        narrative: 'The bandit king has gathered a formidable army. Villages are burning, and the threat grows daily.',
+        choices: [{
+          text: 'Lead a militia to confront them',
+          effect: {
+            influence: [20, 40],
+            health: [-40, -20]
+          },
+          consequence: 'leader'
+        }, {
+          text: 'Negotiate with the bandit king',
+          effect: {
+            gold: [-1000, -500],
+            reputation: [-5, 10]
+          },
+          consequence: 'diplomat'
+        }, {
+          text: 'Flee to safer lands',
+          effect: {
+            influence: [-15, -5],
+            stress: [-10, -5]
+          },
+          consequence: 'refugee'
+        }]
+      },
+      ASSASSINATION_PLOT: {
+        title: 'Assassination Plot Uncovered',
+        narrative: 'Your investigation has revealed a plot to assassinate a high-ranking noble. The conspirators know you\'re onto them.',
+        choices: [{
+          text: 'Alert the authorities immediately',
+          effect: {
+            influence: [15, 30],
+            reputation: [10, 20]
+          },
+          consequence: 'hero'
+        }, {
+          text: 'Confront the conspirators yourself',
+          effect: {
+            health: [-30, -10],
+            reputation: [20, 35]
+          },
+          consequence: 'investigator'
+        }, {
+          text: 'Use this information for personal gain',
+          effect: {
+            gold: [500, 1500],
+            reputation: [-25, -10]
+          },
+          consequence: 'blackmailer'
+        }]
+      },
+      ROYAL_PURGE: {
+        title: 'Royal Purge',
+        narrative: 'The scandal has triggered a royal purge. Accusations fly, and no one is safe from suspicion.',
+        choices: [{
+          text: 'Stand your ground and proclaim innocence',
+          effect: {
+            reputation: [15, 30],
+            influence: [10, 25]
+          },
+          consequence: 'innocent'
+        }, {
+          text: 'Flee into exile',
+          effect: {
+            influence: [-50, -20],
+            stress: [10, 25]
+          },
+          consequence: 'exile'
+        }, {
+          text: 'Testify against others to save yourself',
+          effect: {
+            reputation: [-30, -15],
+            karma: [-20, -10]
+          },
+          consequence: 'betrayer'
+        }]
+      },
+      TRADE_OPPORTUNITY: {
+        title: 'Rare Trade Opportunity',
+        narrative: 'A lucrative trade route has opened up, but it requires significant initial investment.',
+        choices: [{
+          text: 'Invest heavily in the venture',
+          effect: {
+            gold: [-2000, -1000],
+            influence: [10, 25]
+          },
+          consequence: 'invest'
+        }, {
+          text: 'Take a calculated risk with moderate investment',
+          effect: {
+            gold: [-500, -200],
+            influence: [5, 15]
+          },
+          consequence: 'moderate'
+        }, {
+          text: 'Pass on the opportunity',
+          effect: {
+            reputation: [-5, 0]
+          },
+          consequence: 'cautious'
+        }]
+      },
+      FINAL_RECKONING: {
+        title: 'Final Reckoning',
+        narrative: 'The cursed artifact demands its final price. The entity bound to it appears before you.',
+        choices: [{
+          text: 'Destroy the artifact',
+          effect: {
+            health: [-50, -20],
+            karma: [30, 50]
+          },
+          consequence: 'destroyer'
+        }, {
+          text: 'Bargain with the entity',
+          effect: {
+            influence: [20, 40],
+            health: [-20, -10]
+          },
+          consequence: 'diplomat'
+        }, {
+          text: 'Accept the curse as your own',
+          effect: {
+            power_level: [50, 100],
+            health: [-30, -15]
+          },
+          consequence: 'cursed'
+        }]
+      },
+      // Seasonal Event Templates
+      BLOOMING_ROMANCE: {
+        title: 'Spring Blossoms',
+        narrative: 'The spring air carries the sweet scent of blooming flowers, and romance fills the atmosphere.',
+        choices: [{
+          text: 'Pursue a romantic interest',
+          effect: {
+            happiness: [20, 40],
+            relationships: [1, 2]
+          },
+          consequence: 'romantic'
+        }, {
+          text: 'Focus on personal growth',
+          effect: {
+            wisdom: [10, 25],
+            stress: [-10, -5]
+          },
+          consequence: 'introspective'
+        }, {
+          text: 'Throw a garden party',
+          effect: {
+            influence: [10, 20],
+            gold: [-50, -20]
+          },
+          consequence: 'social'
+        }]
+      },
+      SPRING_FESTIVAL: {
+        title: 'Festival of Renewal',
+        narrative: 'The village celebrates the spring festival with flowers, music, and joyous gatherings.',
+        choices: [{
+          text: 'Participate in the celebrations',
+          effect: {
+            happiness: [15, 30],
+            reputation: [5, 15]
+          },
+          consequence: 'festive'
+        }, {
+          text: 'Help organize the festival',
+          effect: {
+            influence: [15, 25],
+            gold: [-30, -10]
+          },
+          consequence: 'organizer'
+        }, {
+          text: 'Use the crowds for business',
+          effect: {
+            gold: [20, 50],
+            reputation: [-5, 5]
+          },
+          consequence: 'merchant'
+        }]
+      },
+      SUMMER_TOURNAMENT: {
+        title: 'Grand Tournament',
+        narrative: 'Warriors from across the land gather for the annual summer tournament, testing their skills in combat.',
+        choices: [{
+          text: 'Enter the tournament',
+          effect: {
+            reputation: [20, 40],
+            health: [-20, -5]
+          },
+          consequence: 'competitor'
+        }, {
+          text: 'Sponsor a contestant',
+          effect: {
+            influence: [10, 20],
+            gold: [-100, -50]
+          },
+          consequence: 'patron'
+        }, {
+          text: 'Watch and learn',
+          effect: {
+            combat_skill: [5, 15],
+            reputation: [5, 10]
+          },
+          consequence: 'spectator'
+        }]
+      },
+      HARVEST_FESTIVAL: {
+        title: 'Harvest Celebration',
+        narrative: 'The autumn harvest brings bounty and gratitude, celebrated with feasts and thanksgiving.',
+        choices: [{
+          text: 'Contribute to the harvest',
+          effect: {
+            karma: [10, 20],
+            community_relations: [15, 25]
+          },
+          consequence: 'contributor'
+        }, {
+          text: 'Host a harvest feast',
+          effect: {
+            influence: [20, 30],
+            gold: [-80, -40]
+          },
+          consequence: 'host'
+        }, {
+          text: 'Trade harvest goods',
+          effect: {
+            gold: [50, 100],
+            influence: [5, 15]
+          },
+          consequence: 'trader'
+        }]
+      },
+      WINTER_SOLSTICE: {
+        title: 'Winter Solstice Ritual',
+        narrative: 'The longest night brings reflection and hope as the sun begins its return journey.',
+        choices: [{
+          text: 'Participate in solstice rituals',
+          effect: {
+            faith: [10, 25],
+            stress: [-15, -5]
+          },
+          consequence: 'spiritual'
+        }, {
+          text: 'Host a solstice gathering',
+          effect: {
+            influence: [15, 25],
+            warmth: [20, 40]
+          },
+          consequence: 'community'
+        }, {
+          text: 'Contemplate the turning year',
+          effect: {
+            wisdom: [15, 30],
+            insight: [10, 20]
+          },
+          consequence: 'philosophical'
+        }]
+      },
+      // Time-based Event Templates
+      RUMORS_OF_DISSENT: {
+        title: 'Whispers of Unrest',
+        narrative: 'Rumors of dissatisfaction with the current regime begin circulating through the streets.',
+        choices: [{
+          text: 'Investigate the rumors',
+          effect: {
+            influence: [5, 15],
+            risk: [10, 20]
+          },
+          consequence: 'investigator'
+        }, {
+          text: 'Ignore the gossip',
+          effect: {
+            stress: [-5, 0]
+          },
+          consequence: 'apathetic'
+        }, {
+          text: 'Spread counter-rumors',
+          effect: {
+            reputation: [-10, -5],
+            influence: [5, 10]
+          },
+          consequence: 'loyalist'
+        }]
+      },
+      MARKET_UNREST: {
+        title: 'Market Instability',
+        narrative: 'Traders report unusual fluctuations in market prices and growing uncertainty among merchants.',
+        choices: [{
+          text: 'Invest in stable goods',
+          effect: {
+            gold: [-200, -100],
+            security: [20, 40]
+          },
+          consequence: 'conservative'
+        }, {
+          text: 'Speculate on market changes',
+          effect: {
+            gold: [-100, 300],
+            risk: [30, 50]
+          },
+          consequence: 'speculator'
+        }, {
+          text: 'Diversify your holdings',
+          effect: {
+            gold: [-50, -20],
+            stability: [15, 25]
+          },
+          consequence: 'balanced'
+        }]
+      },
+      STRANGE_OCCURRENCES: {
+        title: 'Unexplained Phenomena',
+        narrative: 'Strange lights in the sky and unexplained events begin occurring with increasing frequency.',
+        choices: [{
+          text: 'Investigate the phenomena',
+          effect: {
+            knowledge: [10, 25],
+            risk: [10, 20]
+          },
+          consequence: 'curious'
+        }, {
+          text: 'Consult local experts',
+          effect: {
+            gold: [-30, -10],
+            insight: [15, 30]
+          },
+          consequence: 'scholarly'
+        }, {
+          text: 'Dismiss as superstition',
+          effect: {
+            stress: [-10, -5]
+          },
+          consequence: 'skeptical'
+        }]
       }
     };
   }
@@ -544,17 +929,19 @@ class RPGEventGenerator {
   generateEvent(playerContext = {}) {
     const context = this.analyzeContext(playerContext);
     const template = this.selectTemplate(context);
+    const scaledChoices = this.scaleEffectsForDifficulty(this.generateContextualChoices(template.choices, context), 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),
+      choices: scaledChoices,
       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)
+      theme: this.determineTheme(template, context),
+      difficulty: this.calculateDifficultyTier(context.power_level || 0)
     };
   }
 
@@ -573,39 +960,991 @@ class RPGEventGenerator {
   }
 
   /**
-   * Analyze and enrich player context for sophisticated event generation
+   * Initialize thematic training data sets
    * @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 || []
+  initializeThemes() {
+    this.themes = {
+      fantasy: [
+      // 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'],
+      'sci-fi': [
+      // Corporate Intrigue
+      'Megacorporations wage shadow wars through proxy conflicts and data manipulation', 'Neural implants malfunction, flooding your mind with corporate secrets', 'A black-market AI offers forbidden knowledge at the cost of your sanity', 'Corporate espionage turns deadly when rival agents converge on your location', 'Whistleblower data reveals systemic corruption in the highest levels of power',
+      // Cyberpunk Underworld
+      'Hackers breach your personal network, exposing vulnerabilities you never knew existed', 'Street gangs control the undercity with drone swarms and illegal augmentations', 'The dark web pulses with illegal tech trades and forbidden experiments', 'Corporate bounty hunters track you through the neon-lit sprawl', 'Data runners risk everything for the ultimate information score',
+      // Space & Exploration
+      'Alien artifacts whisper secrets from beyond the galactic rim', 'Space pirates demand tribute or face the void of decompression', 'Ancient derelict ships hold treasures and horrors from forgotten eras', 'Wormhole anomalies bend reality, creating unpredictable temporal events', 'Colony worlds rebel against Earth\'s iron-fisted governance',
+      // AI & Technology
+      'Sentient AIs manipulate events from within the global network', 'Nanobot swarms escape containment, evolving beyond their programming', 'Virtual reality simulations bleed into the real world disastrously', 'Genetic engineering experiments create monstrous hybrid beings', 'Quantum computers predict the future, but at what cost to free will?',
+      // Dystopian Society
+      'Social credit systems reward compliance and punish deviation', 'Surveillance drones watch every move, every transaction, every thought', 'Rebellions simmer beneath the surface of totalitarian control', 'Resource wars rage over the last viable mining asteroids', 'Climate engineering projects backfire spectacularly',
+      // Personal & Cybernetic
+      'Implant malfunctions cause vivid hallucinations and system crashes', 'Identity theft becomes literal as someone steals your digital consciousness', 'Memory wipes erase crucial knowledge, leaving you vulnerable', 'Cybernetic enhancements demand maintenance that costs more than you can afford', 'Neural links create unintended telepathic connections with strangers',
+      // Economic & Corporate
+      'Cryptocurrency markets crash, wiping out fortunes in digital dust', 'Hostile takeovers turn friendly acquisitions into bloody boardroom coups', 'Trade wars erupt between orbital habitats and planetary governments', 'Investment opportunities in black-market tech promise riches or ruin', 'Corporate espionage turns personal when family members are leveraged',
+      // Military & Combat
+      'Drone wars rage in the skies above abandoned cities', 'Cyber warfare disables entire infrastructure networks', 'Private military companies offer their services to the highest bidder', 'Nuclear deterrence fails when EMP weapons render missiles useless', 'Bioterrorism releases engineered plagues upon unsuspecting populations',
+      // Mystery & Conspiracy
+      'Government cover-ups hide the truth about alien visitations', 'Time travel experiments create paradoxical timeline fractures', 'Parallel dimensions bleed through, creating impossible phenomena', 'Ancient alien technology reactivates with catastrophic consequences', 'Conspiracy theories prove true, but the reality is far worse',
+      // Environmental & Planetary
+      'Terraforming projects unleash ancient microbes from the soil', 'Climate control systems fail, creating unpredictable weather patterns', 'Asteroid mining operations awaken dormant extraterrestrial threats', 'Ocean acidification drives aquatic mutations to the surface', 'Atmospheric processors malfunction, creating toxic breathing conditions'],
+      historical: [
+      // Medieval Court Intrigue
+      'The king\'s advisors plot in shadowed corners of the great hall', 'Noble houses form secret alliances against the crown', 'Whispers of heresy spread through the royal court like wildfire', 'A foreign diplomat offers treacherous propositions under diplomatic immunity', 'Court jesters hide dangerous truths behind masks of folly',
+      // Warfare & Conquest
+      'Armies mass at the borders, their banners fluttering in the wind of war', 'Siege engines pound ancient walls as defenders hold the line', 'Cavalry charges break enemy formations in clouds of dust and blood', 'Naval blockades starve cities into submission or desperate rebellion', 'Mercenary companies switch sides based on the highest bidder',
+      // Exploration & Discovery
+      'New World expeditions return with gold and strange diseases', 'Ancient artifacts surface from archaeological digs, rewriting history', 'Trade caravans brave bandits and harsh terrains for exotic goods', 'Mapping expeditions chart unknown territories and hostile natives', 'Scientific discoveries challenge religious doctrines and established truths',
+      // Social & Class Conflict
+      'Peasant revolts spread like contagion through the countryside', 'Guilds clash over trade monopolies and apprenticeship rights', 'Religious schisms divide communities along ideological lines', 'Women maneuver within restrictive social structures for power and influence', 'Immigrants bring new customs that clash with traditional ways',
+      // Economic & Mercantile
+      'Market monopolies drive independent merchants to desperation', 'Banking houses manipulate currency values for political gain', 'Trade embargoes create black markets and smuggling operations', 'Agricultural failures lead to famines and social unrest', 'Colonial exploitation enriches the crown while impoverishing subjects',
+      // Political & Diplomatic
+      'Treaty negotiations mask underlying territorial ambitions', 'Spy networks weave webs of deception across national borders', 'Succession crises threaten to plunge nations into civil war', 'Diplomatic incidents escalate into full-scale military conflicts', 'Royal marriages forge alliances that crumble under stress',
+      // Religious & Ideological
+      'Inquisitions root out heresy with fire and torture', 'Crusades call warriors to distant lands for faith and glory', 'Reformation movements challenge the authority of established churches', 'Cult leaders promise salvation through devotion and sacrifice', 'Religious relics inspire pilgrimages and bloody conflicts',
+      // Personal & Dramatic
+      'Family feuds span generations, poisoning bloodlines with vengeance', 'Scandals rock aristocratic families, threatening social standing', 'Personal ambitions clash with familial duties and expectations', 'Love affairs defy social conventions and familial arrangements', 'Betrayals cut deeper than any blade, leaving lasting scars',
+      // Natural & Environmental
+      'Plagues sweep through densely packed cities, claiming thousands', 'Famines force desperate migrations and social breakdowns', 'Natural disasters reveal underlying social and political tensions', 'Harsh winters test the limits of human endurance and charity', 'Droughts drive conflicts over dwindling water resources',
+      // Innovation & Progress
+      'Scientific discoveries revolutionize warfare and exploration', 'Technological innovations disrupt traditional crafts and livelihoods', 'Medical breakthroughs save lives but challenge religious views', 'Educational reforms open knowledge to new social classes', 'Engineering marvels push the boundaries of human capability']
+    };
+
+    // Cultural variants within themes
+    this.cultures = {
+      fantasy: {
+        norse: ['The longships sail into the fjord under the northern lights', 'Runes carved in ancient stone whisper forgotten secrets', 'The mead hall echoes with tales of heroic deeds and tragic fates', 'Berserkers rage through the village leaving destruction in their wake', 'The gods themselves seem to take notice of mortal affairs', 'Viking raiders demand tribute or face the wrath of the axe', 'Shamanic visions reveal the threads of fate woven by the Norns', 'The sacred grove hides a portal to the realm of the Aesir', 'Blood oaths bind warriors to quests of honor and vengeance', 'Thunder rolls as Thor\'s hammer strikes down the unworthy'],
+        arabian: ['The desert winds carry secrets from across the golden sands', 'The sultan\'s palace gleams with marble and precious gems', 'Caravans traverse ancient trade routes laden with exotic spices', 'Djinn emerge from bottles granting wishes with treacherous twists', 'The bazaar bustles with merchants hawking forbidden artifacts', 'Flying carpets soar above the minarets of ancient cities', 'Oasis springs hide treasures guarded by serpentine efreet', 'Bedouin tribes honor ancient codes of hospitality and revenge', 'The caliph\'s viziers plot intricate webs of palace intrigue', 'Magic lamps hold genies bound by oaths older than the desert'],
+        celtic: ['The ancient stone circles hum with druidic power', 'Mists roll in from the moors carrying spectral visitors', 'The high king\'s court debates matters of honor and clan loyalty', 'Leprechauns guard pots of gold at the end of rainbows', 'Banshees wail warnings of impending doom from castle towers', 'The green hills hide fairy mounds and trooping fae', 'Druidic circles perform rituals beneath the full moon', 'Clan tartans flutter as warriors clash in honorable combat', 'The sidhe court offers dangerous bargains to mortal visitors', 'Standing stones mark portals to the otherworld'],
+        asian: ['The imperial court buzzes with whispers of dynastic intrigue', 'Paper lanterns float on mist-shrouded temple lakes', 'The great wall stands as both protector and prison', 'Dragon spirits guard ancestral treasures in mountain monasteries', 'Tea ceremonies reveal secrets shared only with trusted allies', 'Samurai honor demands seppuku for failures of duty', 'The emperor\'s astronomers chart the movements of celestial dragons', 'Rice paddies hide the entrances to underworld spirit realms', 'Calligraphy brushes write prophecies on silk scrolls', 'The five elements balance or clash in matters of fate and fortune']
+      },
+      'sci-fi': {
+        cyberpunk: ['Neon lights reflect off rain-slicked streets in the megacity sprawl', 'Corporate security forces patrol the undercity with neural implants', 'Black market clinics offer experimental augmentations at deadly prices', 'Data runners jack into the net, risking their minds for digital secrets', 'Street gangs control territory with drone swarms and illegal tech', 'Megacorporations wage proxy wars through shell companies and hackers', 'Neural lace interfaces blur the line between human and machine', 'The undergrid pulses with illegal transmissions and rebel broadcasts', 'Synthcoke dealers promise escape from the corporate grind', 'Rogue AIs manifest as ghosts in the machine, manipulating events'],
+        space_opera: ['Star destroyers cast shadows across colonized planets', 'The galactic senate debates matters of interstellar diplomacy', 'Smugglers navigate asteroid fields laden with contraband cargo', 'Alien ambassadors negotiate treaties in crystalline council chambers', 'Hyperspace routes hide pirate ambushes and temporal anomalies', 'The emperor\'s new clothes are actually powered armor', 'Jedi knights wield lightsabers in duels of honor and destiny', 'Space stations orbit gas giants, hubs of trade and intrigue', 'The force guides the worthy through trials of wisdom and combat', 'Rebel alliances form in the shadows of imperial domination'],
+        post_apocalyptic: ['Mutated creatures roam the irradiated wastelands', 'Vault dwellers emerge from underground bunkers into harsh sunlight', 'Caravan masters trade caps for water and ammunition', 'Super mutants patrol ruined highways in power armor', 'The brotherhood preserves technology as holy relics', 'Ghoul settlements offer sanctuary at the cost of sanity', 'Deathclaws stalk the ruins of pre-war cities', 'Enclave remnants cling to old world ideologies', 'Wasteland doctors perform surgery with scavenged medical supplies', 'Tribal shamans commune with the spirits of the old world']
+      },
+      historical: {
+        medieval: ['Knights joust in tournament fields beneath colorful pennants', 'The castle keep stands as bastion against siege engines', 'Peasant revolts spread like wildfire through feudal lands', 'The black death claims lives across town and countryside', 'Alchemists in hidden laboratories seek the philosopher\'s stone', 'Crusader armies march under banners of faith and conquest', 'Courtly love complicates matters of honor and duty', 'The Magna Carta is sealed with wax and noble promises', 'Witch hunters burn heretics at public stake executions', 'Guild masters guard trade secrets with jealous vigilance'],
+        victorian: ['Steam engines power the industrial revolution across soot-stained cities', 'The British Empire spans continents with colonial ambitions', 'Social reformers challenge the rigid class structures of society', 'Spiritualists commune with the dead in dimly lit seances', 'Jack the Ripper stalks the fog-shrouded streets of Whitechapel', 'The industrialists build empires on coal and child labor', 'Suffragettes demand voting rights through peaceful protest', 'Opium dens offer escape from the pressures of imperial duty', 'The great exhibition showcases marvels of modern invention', 'Darwin\'s theories challenge religious doctrines of creation'],
+        ancient_roman: ['Gladiators fight for glory in the Colosseum\'s sandy arena', 'The Roman Senate debates matters of republic and empire', 'Barbarian hordes threaten the borders of civilized lands', 'The aqueducts carry water across vast engineering marvels', 'Political assassinations reshape the corridors of power', 'Slave revolts challenge the foundations of imperial society', 'The gods demand tribute through elaborate public ceremonies', 'Military legions march under eagles forged in sacred fires', 'Patrician families feud over matters of honor and inheritance', 'The imperial palace echoes with plots and betrayals']
+      }
+    };
+
+    // Seasonal and time-based event templates
+    this.seasonalEvents = {
+      spring: {
+        templates: ['BLOOMING_ROMANCE', 'SPRING_FESTIVAL', 'NEW_BEGINNINGS'],
+        modifiers: {
+          happiness: 1.2,
+          romance_events: 1.5,
+          renewal_events: 2.0
+        }
+      },
+      summer: {
+        templates: ['SUMMER_TOURNAMENT', 'BEACH_FESTIVAL', 'HARVEST_PREP'],
+        modifiers: {
+          health: 1.1,
+          activity_events: 1.3,
+          celebration_events: 1.8
+        }
+      },
+      autumn: {
+        templates: ['HARVEST_FESTIVAL', 'AUTUMN_HUNT', 'WINTER_PREP'],
+        modifiers: {
+          wealth: 1.3,
+          preparation_events: 1.6,
+          scarcity_events: 1.2
+        }
+      },
+      winter: {
+        templates: ['WINTER_SOLSTICE', 'HOLIDAY_CELEBRATION', 'SURVIVAL_CHALLENGE'],
+        modifiers: {
+          stress: 1.4,
+          survival_events: 1.8,
+          warmth_events: 2.0,
+          scarcity_events: 1.5
+        }
+      }
+    };
+
+    // Time-based event chains (events that evolve over time)
+    this.timeBasedEventChains = {
+      POLITICAL_UPRISING: {
+        name: 'Political Uprising',
+        description: 'A rebellion builds against oppressive rule',
+        stages: [{
+          day: 1,
+          template: 'RUMORS_OF_DISSENT'
+        }, {
+          day: 7,
+          template: 'PUBLIC_PROTESTS'
+        }, {
+          day: 14,
+          template: 'OPEN_REBELLION'
+        }, {
+          day: 21,
+          template: 'REVOLUTIONARY_CLIMAX'
+        }]
+      },
+      ECONOMIC_COLLAPSE: {
+        name: 'Economic Collapse',
+        description: 'A financial crisis spirals out of control',
+        stages: [{
+          day: 1,
+          template: 'MARKET_UNREST'
+        }, {
+          day: 5,
+          template: 'BANK_RUN'
+        }, {
+          day: 10,
+          template: 'ECONOMIC_CRISIS'
+        }, {
+          day: 15,
+          template: 'SOCIAL_UNREST'
+        }]
+      },
+      MYSTICAL_AWAKENING: {
+        name: 'Mystical Awakening',
+        description: 'Ancient powers stir and manifest',
+        stages: [{
+          day: 1,
+          template: 'STRANGE_OCCURRENCES'
+        }, {
+          day: 3,
+          template: 'MAGICAL_SURGES'
+        }, {
+          day: 7,
+          template: 'ARCANE_MANIFESTATION'
+        }, {
+          day: 10,
+          template: 'MYSTICAL_CLIMAX'
+        }]
+      }
     };
-    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
+   * Get training data for a specific theme and culture
+   * @param {string} theme - The theme to get training data for
+   * @param {string} culture - The cultural variant (optional)
+   * @returns {Array} Training data for the specified theme/culture
+   * @private
+   */
+  getThemeTrainingData(theme, culture) {
+    const baseThemeData = this.themes[theme] || this.themes.fantasy;
+    if (!culture || !this.cultures[theme] || !this.cultures[theme][culture]) {
+      return baseThemeData;
+    }
+    const culturalData = this.cultures[theme][culture];
+    const blendRatio = 0.6;
+    const baseCount = Math.floor(baseThemeData.length * blendRatio);
+    const cultureCount = Math.floor(culturalData.length * (1 - blendRatio));
+    const blendedData = [...baseThemeData.slice(0, baseCount), ...culturalData.slice(0, cultureCount)];
+    return this.chance.shuffle(blendedData);
+  }
+
+  /**
+   * Initialize event chain definitions
+   * @private
+   */
+  initializeChainDefinitions() {
+    return {
+      BANDIT_RISING: {
+        name: 'Bandit Rising',
+        description: 'A bandit threat that escalates over time',
+        stages: [{
+          template: 'BANDIT_AMBUSH',
+          delay: 0,
+          triggerNext: {
+            choice: 'bandit',
+            delay: 3
+          }
+        }, {
+          template: 'BANDIT_KING',
+          delay: 3,
+          triggerNext: {
+            choice: 'hero',
+            delay: 5
+          }
+        }, {
+          template: 'BANDIT_ARMY',
+          delay: 5
+        }]
+      },
+      COURT_SCANDAL_CHAIN: {
+        name: 'Royal Scandal',
+        description: 'A court intrigue that unfolds in multiple acts',
+        stages: [{
+          template: 'COURT_SCANDAL',
+          delay: 0,
+          triggerNext: {
+            choice: 'investigator',
+            delay: 2
+          }
+        }, {
+          template: 'ASSASSINATION_PLOT',
+          delay: 2,
+          triggerNext: {
+            choice: 'intervene',
+            delay: 4
+          }
+        }, {
+          template: 'ROYAL_PURGE',
+          delay: 4
+        }]
+      },
+      CURSE_OF_THE_ARTIFACT: {
+        name: 'Cursed Artifact',
+        description: 'An ancient curse that manifests in stages',
+        stages: [{
+          template: 'ANCIENT_CURSE',
+          delay: 0,
+          triggerNext: {
+            automatic: true,
+            delay: 2
+          }
+        }, {
+          template: 'GHOSTLY_VISITATION',
+          delay: 2,
+          triggerNext: {
+            automatic: true,
+            delay: 3
+          }
+        }, {
+          template: 'FINAL_RECKONING',
+          delay: 3
+        }]
+      },
+      MERCHANT_EMPIRE: {
+        name: 'Rising Merchant Empire',
+        description: 'Building a trade empire with escalating opportunities',
+        stages: [{
+          template: 'TRADE_OPPORTUNITY',
+          delay: 0,
+          triggerNext: {
+            choice: 'invest',
+            delay: 4
+          }
+        }, {
+          template: 'MARKET_CRASH',
+          delay: 4,
+          triggerNext: {
+            choice: 'rebuild',
+            delay: 6
+          }
+        }, {
+          template: 'TRADE_WAR',
+          delay: 6
+        }]
+      }
+    };
+  }
+
+  /**
+   * Start an event chain
+   * @param {string} chainId - ID of the chain to start
+   * @param {Object} playerContext - Player context
+   * @returns {Object|null} First event in the chain or null
+   */
+  startChain(chainId, playerContext = {}) {
+    const chainDef = this.chainDefinitions[chainId];
+    if (!chainDef) return null;
+    const chain = {
+      id: `chain_${Date.now()}_${this.chance.guid().substring(0, 8)}`,
+      definition: chainId,
+      stage: 0,
+      startTime: Date.now(),
+      playerContext: {
+        ...playerContext
+      }
+    };
+    this.activeChains.set(chain.id, chain);
+
+    // Generate first event in chain
+    return this.generateChainEvent(chain);
+  }
+
+  /**
+   * Generate an event from an active chain
+   * @param {Object} chain - Chain object
+   * @returns {Object|null} Generated event or null
+   */
+  generateChainEvent(chain) {
+    const chainDef = this.chainDefinitions[chain.definition];
+    if (!chainDef || chain.stage >= chainDef.stages.length) return null;
+    const stage = chainDef.stages[chain.stage];
+    const template = this.templates[stage.template];
+    if (!template) return null;
+    const context = this.analyzeContext(chain.playerContext);
+    return {
+      id: `event_${chain.id}_${chain.stage}`,
+      title: this.generateDynamicTitle(template, context),
+      description: this.generateRichDescription(template, context),
+      narrative: template.narrative,
+      choices: this.generateContextualChoices(template.choices, context),
+      type: stage.template,
+      consequence: null,
+      context: context,
+      urgency: this.calculateUrgency(template, context),
+      theme: this.determineTheme(template, context),
+      chainId: chain.id,
+      chainStage: chain.stage,
+      isChainEvent: true
+    };
+  }
+
+  /**
+   * Advance an event chain based on player choice
+   * @param {string} chainId - Chain ID
+   * @param {string} choice - Player choice consequence
+   * @returns {Object|null} Next event in chain or null
+   */
+  advanceChain(chainId, choice) {
+    const chain = this.activeChains.get(chainId);
+    if (!chain) return null;
+    const chainDef = this.chainDefinitions[chain.definition];
+    const currentStage = chainDef.stages[chain.stage];
+
+    // Check if current stage triggers next based on choice
+    if (currentStage.triggerNext && currentStage.triggerNext.choice === choice) {
+      chain.stage++;
+      chain.playerContext = {
+        ...chain.playerContext,
+        lastChoice: choice
+      };
+
+      // Schedule next event for game integration
+      if (chain.stage < chainDef.stages.length) {
+        chain.nextEventTime = this.timeSystem.currentDay + currentStage.triggerNext.delay;
+        chain.nextEventTemplate = chainDef.stages[chain.stage].template;
+        // In a real game, save this chain state and check for due events on each game day
+      }
+      return this.generateChainEvent(chain);
+    }
+    return null;
+  }
+
+  /**
+   * Get all active chains
+   * @returns {Array} Array of active chain objects
+   */
+  getActiveChains() {
+    return Array.from(this.activeChains.values());
+  }
+
+  /**
+   * End a chain
+   * @param {string} chainId - Chain ID to end
+   */
+  endChain(chainId) {
+    this.activeChains.delete(chainId);
+  }
+
+  /**
+   * Advance game time and trigger time-based events
+   * @param {number} days - Number of days to advance (default: 1)
+   * @returns {Array} Array of time-based events triggered
+   */
+  advanceTime(days = 1) {
+    const triggeredEvents = [];
+    for (let i = 0; i < days; i++) {
+      this.timeSystem.currentDay++;
+      const seasonLength = 90;
+      const seasonIndex = Math.floor((this.timeSystem.currentDay - 1) / seasonLength) % 4;
+      const seasons = ['spring', 'summer', 'autumn', 'winter'];
+      const newSeason = seasons[seasonIndex];
+      if (newSeason !== this.timeSystem.currentSeason) {
+        this.timeSystem.currentSeason = newSeason;
+        triggeredEvents.push({
+          type: 'seasonal_change',
+          season: newSeason,
+          day: this.timeSystem.currentDay
+        });
+      }
+
+      // Check for time-based event triggers
+      const dayEvents = this.checkTimeBasedEventTriggers();
+      triggeredEvents.push(...dayEvents);
+    }
+    return triggeredEvents;
+  }
+
+  /**
+   * Check for time-based event triggers
+   * @returns {Array} Array of triggered events
+   * @private
+   */
+  checkTimeBasedEventTriggers() {
+    const triggeredEvents = [];
+    for (const [chainId, chainData] of this.timeSystem.timeBasedEvents.entries()) {
+      const daysSinceStart = this.timeSystem.currentDay - chainData.startDay;
+      for (const stage of chainData.chain.stages) {
+        if (stage.day === daysSinceStart && !chainData.completedStages.includes(stage.day)) {
+          chainData.completedStages.push(stage.day);
+          const event = {
+            type: 'time_based_chain',
+            chainId: chainId,
+            stage: stage,
+            day: this.timeSystem.currentDay,
+            template: this.templates[stage.template]
+          };
+          triggeredEvents.push(event);
+          break; // Only trigger one stage per day
+        }
+      }
+    }
+    if (this.chance.bool({
+      likelihood: 10
+    })) {
+      const seasonalData = this.seasonalEvents[this.timeSystem.currentSeason];
+      if (seasonalData && seasonalData.templates.length > 0) {
+        const randomTemplate = this.chance.pickone(seasonalData.templates);
+        if (this.templates[randomTemplate]) {
+          triggeredEvents.push({
+            type: 'seasonal_random',
+            season: this.timeSystem.currentSeason,
+            template: this.templates[randomTemplate],
+            day: this.timeSystem.currentDay
+          });
+        }
+      }
+    }
+    return triggeredEvents;
+  }
+
+  /**
+   * Start a time-based event chain
+   * @param {string} chainName - Name of the chain to start
+   * @returns {boolean} Success status
+   */
+  startTimeBasedChain(chainName) {
+    const chain = this.timeBasedEventChains[chainName];
+    if (!chain) return false;
+    const chainId = `time_chain_${Date.now()}_${this.chance.guid().substring(0, 8)}`;
+    this.timeSystem.timeBasedEvents.set(chainId, {
+      definition: chainName,
+      stage: 0,
+      startDay: this.timeSystem.currentDay,
+      completedStages: new Set()
+    });
+    return true;
+  }
+
+  /**
+   * Get current game time information
+   * @returns {Object} Time system state
+   */
+  getCurrentTime() {
+    var _this$seasonalEvents$;
+    return {
+      day: this.timeSystem.currentDay,
+      season: this.timeSystem.currentSeason,
+      year: Math.ceil(this.timeSystem.currentDay / 360),
+      // Roughly 360 days per year
+      seasonalModifiers: ((_this$seasonalEvents$ = this.seasonalEvents[this.timeSystem.currentSeason]) === null || _this$seasonalEvents$ === void 0 ? void 0 : _this$seasonalEvents$.modifiers) || {}
+    };
+  }
+
+  /**
+   * Advance to the next game day and process any due time-based events
+   * @returns {Array} Array of events that are now ready to trigger
+   */
+  advanceGameDay() {
+    this.timeSystem.currentDay++;
+    const seasonLength = 90;
+    const seasonIndex = Math.floor((this.timeSystem.currentDay - 1) / seasonLength) % 4;
+    const seasons = ['spring', 'summer', 'autumn', 'winter'];
+    const newSeason = seasons[seasonIndex];
+    if (newSeason !== this.timeSystem.currentSeason) {
+      this.timeSystem.currentSeason = newSeason;
+    }
+    const dueEvents = [];
+    for (const [chainId, chainData] of this.timeSystem.timeBasedEvents.entries()) {
+      const chainDef = this.timeBasedEventChains[chainData.definition];
+      if (!chainDef) continue;
+      const daysSinceStart = this.timeSystem.currentDay - chainData.startDay;
+      for (let i = chainData.stage; i < chainDef.stages.length; i++) {
+        const stage = chainDef.stages[i];
+        if (stage.day <= daysSinceStart && !chainData.completedStages.has(i)) {
+          const event = {
+            type: 'time_based_chain',
+            chainId: chainId,
+            template: this.templates[stage.template],
+            day: this.timeSystem.currentDay,
+            chainStage: i,
+            stageDay: stage.day
+          };
+          dueEvents.push(event);
+          chainData.completedStages.add(i);
+          chainData.stage = Math.max(chainData.stage, i + 1);
+        }
+      }
+    }
+    if (this.chance.bool({
+      likelihood: 10
+    })) {
+      const seasonalData = this.seasonalEvents[this.timeSystem.currentSeason];
+      if (seasonalData && seasonalData.templates.length > 0) {
+        const randomTemplate = this.chance.pickone(seasonalData.templates);
+        if (this.templates[randomTemplate]) {
+          dueEvents.push({
+            type: 'seasonal_random',
+            season: this.timeSystem.currentSeason,
+            template: this.templates[randomTemplate],
+            day: this.timeSystem.currentDay
+          });
+        }
+      }
+    }
+    return dueEvents;
+  }
+
+  /**
+   * Get all currently active time-based chains with their status
+   * @returns {Array} Array of chain status objects
+   */
+  getActiveTimeChains() {
+    const activeChains = [];
+    for (const [chainId, chainData] of this.timeSystem.timeBasedEvents.entries()) {
+      const chainDef = this.timeBasedEventChains[chainData.definition];
+      if (chainDef) {
+        activeChains.push({
+          id: chainId,
+          name: chainDef.name,
+          description: chainDef.description,
+          currentStage: chainData.stage,
+          totalStages: chainDef.stages.length,
+          nextEventDay: chainData.nextEventTime || null,
+          nextEventTemplate: chainData.nextEventTemplate || null,
+          startDay: chainData.startDay,
+          daysActive: this.timeSystem.currentDay - chainData.startDay
+        });
+      }
+    }
+    return activeChains;
+  }
+
+  /**
+   * Get game state for saving (includes time system and active chains)
+   * @returns {Object} Serializable game state
+   */
+  getGameState() {
+    return {
+      timeSystem: {
+        currentDay: this.timeSystem.currentDay,
+        currentSeason: this.timeSystem.currentSeason,
+        gameYear: Math.ceil(this.timeSystem.currentDay / 360)
+      },
+      activeChains: Array.from(this.timeSystem.timeBasedEvents.entries()).map(([id, data]) => ({
+        id,
+        definition: data.definition,
+        stage: data.stage,
+        startDay: data.startDay,
+        nextEventTime: data.nextEventTime || null,
+        nextEventTemplate: data.nextEventTemplate || null,
+        completedStages: [...data.completedStages]
+      })),
+      theme: this.theme,
+      culture: this.culture
+    };
+  }
+
+  /**
+   * Load game state (restores time system and active chains)
+   * @param {Object} gameState - State object from getGameState()
+   * @returns {boolean} Success status
+   */
+  loadGameState(gameState) {
+    try {
+      if (gameState.timeSystem) {
+        this.timeSystem.currentDay = gameState.timeSystem.currentDay || 1;
+        this.timeSystem.currentSeason = gameState.timeSystem.currentSeason || 'spring';
+        this.timeSystem.gameYear = gameState.timeSystem.gameYear || 1;
+      }
+      this.timeSystem.timeBasedEvents.clear();
+      if (gameState.activeChains) {
+        gameState.activeChains.forEach(chainData => {
+          this.timeSystem.timeBasedEvents.set(chainData.id, {
+            definition: chainData.definition,
+            stage: chainData.stage,
+            startDay: chainData.startDay,
+            nextEventTime: chainData.nextEventTime,
+            nextEventTemplate: chainData.nextEventTemplate,
+            completedStages: new Set(chainData.completedStages || [])
+          });
+        });
+      }
+      if (gameState.theme) this.theme = gameState.theme;
+      if (gameState.culture) this.culture = gameState.culture;
+      return true;
+    } catch (error) {
+      console.warn('Failed to load game state:', error.message);
+      return false;
+    }
+  }
+
+  /**
+   * Generate a time-aware event that considers current season and time-based factors
+   * @param {Object} playerContext - Player context
+   * @returns {Object} Generated event with time awareness
+   */
+  generateTimeAwareEvent(playerContext = {}) {
+    const context = this.analyzeContext(playerContext);
+    const currentTime = this.getCurrentTime();
+    const seasonalMods = currentTime.seasonalModifiers;
+    Object.keys(seasonalMods).forEach(key => {
+      if (context[key] !== undefined) {
+        context[key] *= seasonalMods[key];
+      }
+    });
+    const template = this.selectTemplate(context);
+    const scaledChoices = this.scaleEffectsForDifficulty(this.generateContextualChoices(template.choices, context), 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: scaledChoices,
+      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),
+      difficulty: this.calculateDifficultyTier(context.power_level || 0),
+      timeInfo: currentTime
+    };
+  }
+
+  /**
+   * Register a custom event template
+   * @param {string} templateId - Unique identifier for the template
+   * @param {Object} template - Event template object
+   * @param {string} template.title - Event title
+   * @param {string} template.narrative - Event description
+   * @param {Array} template.choices - Array of choice objects
+   * @param {boolean} override - Whether to override existing template
+   * @returns {boolean} Success status
+   */
+  registerEventTemplate(templateId, template, override = false) {
+    if (!templateId || typeof templateId !== 'string') {
+      console.warn('Invalid template ID provided');
+      return false;
+    }
+    if (!template || !template.title || !template.narrative || !Array.isArray(template.choices)) {
+      console.warn('Invalid template structure. Required: title, narrative, choices[]');
+      return false;
+    }
+    if (this.templates[templateId] && !override) {
+      console.warn(`Template '${templateId}' already exists. Use override=true to replace it.`);
+      return false;
+    }
+    for (const choice of template.choices) {
+      if (!choice.text || typeof choice.text !== 'string') {
+        console.warn(`Invalid choice structure in template '${templateId}': missing 'text'`);
+        return false;
+      }
+    }
+    this.templates[templateId] = {
+      title: template.title,
+      narrative: template.narrative,
+      choices: template.choices
+    };
+    if (!this.customTemplates) {
+      this.customTemplates = new Set();
+    }
+    this.customTemplates.add(templateId);
+    return true;
+  }
+
+  /**
+   * Unregister a custom event template
+   * @param {string} templateId - Template ID to remove
+   * @returns {boolean} Success status
+   */
+  unregisterEventTemplate(templateId) {
+    if (!this.customTemplates || !this.customTemplates.has(templateId)) {
+      console.warn(`Template '${templateId}' is not a registered custom template`);
+      return false;
+    }
+    delete this.templates[templateId];
+    this.customTemplates.delete(templateId);
+    return true;
+  }
+
+  /**
+   * Get all registered custom templates
+   * @returns {Array} Array of custom template IDs
+   */
+  getCustomTemplates() {
+    return this.customTemplates ? Array.from(this.customTemplates) : [];
+  }
+
+  /**
+   * Add custom training data for Markov chain generation
+   * @param {Array|string} data - Training data (array of strings or single string)
+   * @param {string} category - Category name for organization
+   * @returns {boolean} Success status
+   */
+  addCustomTrainingData(data, category) {
+    if (category === undefined) category = 'custom';
+    if (!data) return false;
+    if (!this.customTrainingData) {
+      this.customTrainingData = {};
+    }
+    if (!this.customTrainingData[category]) {
+      this.customTrainingData[category] = [];
+    }
+    const dataArray = Array.isArray(data) ? data : [data];
+    const validData = dataArray.filter(function (item) {
+      return typeof item === 'string' && item.trim().length > 0;
+    });
+    if (validData.length === 0) return false;
+    this.customTrainingData[category] = this.customTrainingData[category].concat(validData);
+    try {
+      const allData = this.getCombinedTrainingData();
+      this.markovGenerator.addData(allData);
+      return true;
+    } catch (error) {
+      return false;
+    }
+  }
+
+  /**
+   * Remove custom training data
+   * @param {string} category - Category to remove (removes all data in category)
+   * @returns {boolean} Success status
+   */
+  removeTrainingData(category) {
+    if (!this.customTrainingData || !this.customTrainingData[category]) {
+      console.warn(`Training data category '${category}' not found`);
+      return false;
+    }
+    delete this.customTrainingData[category];
+    const allData = this.getCombinedTrainingData();
+    try {
+      this.markovGenerator.addData(allData);
+    } catch (error) {
+      console.warn('Failed to retrain Markov generator after removal:', error.message);
+      return false;
+    }
+    return true;
+  }
+
+  /**
+   * Get combined training data (base + custom)
+   * @returns {Array} Combined training data array
+   * @private
+   */
+  getCombinedTrainingData() {
+    let combinedData = [];
+    const themeData = this.getThemeTrainingData(this.theme || 'fantasy', this.culture);
+    combinedData.push(...themeData);
+    if (this.customTrainingData) {
+      Object.values(this.customTrainingData).forEach(categoryData => {
+        combinedData.push(...categoryData);
+      });
+    }
+    return combinedData;
+  }
+
+  /**
+   * Register a custom event chain
+   * @param {string} chainId - Unique identifier for the chain
+   * @param {Object} chainConfig - Chain configuration
+   * @param {string} chainConfig.name - Display name for the chain
+   * @param {string} chainConfig.description - Chain description
+   * @param {Array} chainConfig.stages - Array of stage objects
+   * @param {boolean} override - Whether to override existing chain
+   * @returns {boolean} Success status
+   */
+  registerEventChain(chainId, chainConfig, override = false) {
+    if (!chainId || typeof chainId !== 'string') {
+      console.warn('Invalid chain ID provided');
+      return false;
+    }
+    if (!chainConfig || !chainConfig.name || !chainConfig.description || !Array.isArray(chainConfig.stages)) {
+      console.warn('Invalid chain configuration. Required: name, description, stages[]');
+      return false;
+    }
+    if (this.timeBasedEventChains[chainId] && !override) {
+      console.warn(`Chain '${chainId}' already exists. Use override=true to replace it.`);
+      return false;
+    }
+    for (let i = 0; i < chainConfig.stages.length; i++) {
+      const stage = chainConfig.stages[i];
+      if (!stage.day || !stage.template) {
+        console.warn(`Invalid stage ${i} in chain '${chainId}': missing 'day' or 'template'`);
+        return false;
+      }
+      if (!this.templates[stage.template]) {
+        console.warn(`Template '${stage.template}' in chain '${chainId}' does not exist`);
+        return false;
+      }
+    }
+    this.timeBasedEventChains[chainId] = {
+      name: chainConfig.name,
+      description: chainConfig.description,
+      stages: chainConfig.stages
+    };
+    if (!this.customChains) {
+      this.customChains = new Set();
+    }
+    this.customChains.add(chainId);
+    return true;
+  }
+
+  /**
+   * Unregister a custom event chain
+   * @param {string} chainId - Chain ID to remove
+   * @returns {boolean} Success status
+   */
+  unregisterEventChain(chainId) {
+    if (!this.customChains || !this.customChains.has(chainId)) {
+      console.warn(`Chain '${chainId}' is not a registered custom chain`);
+      return false;
+    }
+    delete this.timeBasedEventChains[chainId];
+    this.customChains.delete(chainId);
+    for (const [instanceId, chainData] of this.timeSystem.timeBasedEvents.entries()) {
+      if (chainData.chain === this.timeBasedEventChains[chainId]) {
+        this.timeSystem.timeBasedEvents.delete(instanceId);
+      }
+    }
+    return true;
+  }
+
+  /**
+   * Get all registered custom chains
+   * @returns {Array} Array of custom chain IDs
+   */
+  getCustomChains() {
+    return this.customChains ? Array.from(this.customChains) : [];
+  }
+
+  /**
+   * Export all custom content for backup/sharing
+   * @returns {Object} Exported custom content
+   */
+  exportCustomContent() {
+    return {
+      templates: Array.from(this.customTemplates || []).reduce((obj, id) => {
+        obj[id] = this.templates[id];
+        return obj;
+      }, {}),
+      trainingData: this.customTrainingData || {},
+      chains: Array.from(this.customChains || []).reduce((obj, id) => {
+        obj[id] = this.timeBasedEventChains[id];
+        return obj;
+      }, {})
+    };
+  }
+
+  /**
+   * Import custom content from export
+   * @param {Object} content - Exported custom content
+   * @param {boolean} override - Whether to override existing content
+   * @returns {Object} Import results
+   */
+  importCustomContent(content, override = false) {
+    const results = {
+      templates: {
+        success: 0,
+        failed: 0
+      },
+      trainingData: {
+        success: 0,
+        failed: 0
+      },
+      chains: {
+        success: 0,
+        failed: 0
+      }
+    };
+    if (content.templates) {
+      Object.entries(content.templates).forEach(([id, template]) => {
+        if (this.registerEventTemplate(id, template, override)) {
+          results.templates.success++;
+        } else {
+          results.templates.failed++;
+        }
+      });
+    }
+    if (content.trainingData) {
+      Object.entries(content.trainingData).forEach(([category, data]) => {
+        if (this.addCustomTrainingData(data, category)) {
+          results.trainingData.success++;
+        } else {
+          results.trainingData.failed++;
+        }
+      });
+    }
+    if (content.chains) {
+      Object.entries(content.chains).forEach(([id, chain]) => {
+        if (this.registerEventChain(id, chain, override)) {
+          results.chains.success++;
+        } else {
+          results.chains.failed++;
+        }
+      });
+    }
+    return results;
+  }
+
+  /**
+   * Analyze and enrich player context for sophisticated event generation
+   * @private
+   */
+  analyzeContext(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 || this.timeSystem.currentSeason,
+      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) {
@@ -633,6 +1972,94 @@ class RPGEventGenerator {
     return Math.max(0, power);
   }
 
+  /**
+   * Calculate appropriate difficulty tier based on player power level
+   * @param {number} powerLevel - Player's calculated power level
+   * @returns {string} Difficulty tier ('easy', 'normal', 'hard', 'legendary')
+   */
+  calculateDifficultyTier(powerLevel) {
+    if (powerLevel <= 50) return 'easy';
+    if (powerLevel <= 150) return 'normal';
+    if (powerLevel <= 300) return 'hard';
+    return 'legendary';
+  }
+
+  /**
+   * Scale event effects based on difficulty and player power level
+   * @param {Array} choices - Event choices with effects
+   * @param {Object} context - Player context
+   * @returns {Array} Scaled choices
+   */
+  scaleEffectsForDifficulty(choices, context) {
+    const powerLevel = context.power_level || 0;
+    const difficultyTier = this.calculateDifficultyTier(powerLevel);
+    const settings = this.difficultySettings[difficultyTier];
+    return choices.map(choice => {
+      const scaledChoice = {
+        ...choice
+      };
+      if (choice.effect) {
+        scaledChoice.effect = {
+          ...choice.effect
+        };
+        Object.keys(scaledChoice.effect).forEach(key => {
+          const value = scaledChoice.effect[key];
+          if (Array.isArray(value)) {
+            if (key.includes('gold') || key.includes('influence') || key.includes('reputation') || key.includes('knowledge') || key.includes('karma')) {
+              scaledChoice.effect[key] = value.map(v => Math.round(v * settings.rewardMultiplier));
+            } else if (key.includes('health') || key.includes('stress')) {
+              scaledChoice.effect[key] = value.map(v => Math.round(v * settings.penaltyMultiplier));
+            }
+          }
+        });
+      }
+      return scaledChoice;
+    });
+  }
+
+  /**
+   * Adjust template weights based on appropriate challenge level
+   * @param {Object} baseWeights - Base template weights
+   * @param {Object} context - Player context
+   * @returns {Object} Adjusted weights
+   */
+  adjustWeightsForDifficulty(baseWeights, context) {
+    const powerLevel = context.power_level || 0;
+    const difficultyTier = this.calculateDifficultyTier(powerLevel);
+    const challengeRatings = {
+      COURT_SCANDAL: 3,
+      NOBLE_DUEL: 4,
+      THIEVES_GUILD: 5,
+      BLACKMAIL_OPPORTUNITY: 4,
+      ANCIENT_CURSE: 6,
+      GHOSTLY_VISITATION: 5,
+      FORBIDDEN_LOVE: 3,
+      FAMILY_SECRET: 3,
+      LOST_CIVILIZATION: 7,
+      BANDIT_KING: 6,
+      MARKET_CRASH: 4,
+      TRADE_WAR: 5,
+      DESERTION_TEMPTATION: 2,
+      MERCENARY_CONTRACT: 5
+    };
+    const adjustedWeights = {
+      ...baseWeights
+    };
+    Object.keys(adjustedWeights).forEach(templateKey => {
+      const rating = challengeRatings[templateKey] || 5;
+      const powerRatio = powerLevel / 100; // Normalize power level
+
+      if (rating < powerRatio + 2) {
+        adjustedWeights[templateKey] *= 0.5;
+      } else if (rating >= powerRatio + 2 && rating <= powerRatio + 5) {
+        adjustedWeights[templateKey] *= 1.5;
+      } else if (rating > powerRatio + 6) {
+        adjustedWeights[templateKey] *= 0.3;
+      }
+    });
+    return adjustedWeights;
+  }
+
   /**
    * Calculate life experience factor
    * @private
@@ -676,8 +2103,9 @@ class RPGEventGenerator {
       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);
+    const difficultyAdjustedWeights = this.adjustWeightsForDifficulty(baseWeights, context);
+    const totalWeight = Object.values(difficultyAdjustedWeights).reduce((sum, w) => sum + w, 0);
+    const normalizedWeights = Object.values(difficultyAdjustedWeights).map(w => w / totalWeight);
     return normalizedWeights;
   }