rpg-event-generator 1.3.0 → 2.0.1

package/demo.js

@@ -3,7 +3,7 @@
 const { RPGEventGenerator } = require('./dist/index.js');
 
 const DEMO_CONFIG = {
-  version: '1.3.0',
+  version: '2.0.0',
   showErrors: true,
   pauseBetweenDemos: false
 };
@@ -579,9 +579,158 @@ function runDemo() {
   demoSystemStatus(enhancedGenerator);
   demoAdvancedUsage(enhancedGenerator);
 
+  printHeader('🚀 v2.0.0 FEATURE DEMOS');
+
+  // v2.0.0 Feature Demos
+  demoCustomRuleEngine();
+  demoThemeCreator();
+  demoPureMarkovMode();
+  demoEventEconomy();
+
   printHeader('✅ DEMO COMPLETE');
-  console.log('🎉 All enhanced features demonstrated successfully!');
-  console.log('📦 Version 1.3.0 delivers powerful new capabilities while maintaining full backward compatibility.');
-  console.log('🚀 Ready for future enhancements and releases!');
+  console.log('🎉 All v2.0.0 features demonstrated successfully!');
+  console.log('📦 Version 2.0.0 delivers revolutionary new capabilities with full backward compatibility.');
+  console.log('🚀 Production-ready for game development!');
+}
+
+// v2.0.0 Feature Demos
+function demoCustomRuleEngine() {
+  printSection('🧠 Demo 18: Custom Rule Engine (v2.0.0)');
+
+  const generator = new RPGEventGenerator({ enableRuleEngine: true });
+
+  // Create a custom rule for wealthy players
+  const wealthyRule = {
+    conditions: [
+      { type: 'stat_greater_than', params: { stat: 'gold', value: 1000 } }
+    ],
+    effects: {
+      modifyChoices: {
+        multiply: { gold: 1.3 },
+        add: { reputation: 5 }
+      },
+      addTags: ['wealthy_player_bonus']
+    }
+  };
+
+  safeExecute(() => {
+    generator.addCustomRule('wealthy_bonus', wealthyRule);
+    printResult('Rule added', 'wealthy_bonus');
+
+    // Test with wealthy player
+    const wealthyEvent = generator.generateEvent({ gold: 2000 });
+    printResult('Wealthy player event', wealthyEvent.title);
+    printResult('Tags applied', wealthyEvent.tags?.join(', ') || 'none');
+
+    // Test with poor player
+    const poorEvent = generator.generateEvent({ gold: 100 });
+    printResult('Poor player event', poorEvent.title);
+    printResult('Tags applied', poorEvent.tags?.join(', ') || 'none');
+
+    printResult('Active rules', Object.keys(generator.getCustomRules()).length);
+  }, 'custom rule engine');
+}
+
+function demoThemeCreator() {
+  printSection('🎨 Demo 19: Theme Creator (v2.0.0)');
+
+  const customTrainingData = [
+    'Neon-lit cantinas pulse with quantum energy',
+    'Robotic bartenders serve drinks that change your memories',
+    'Space cowboys duel with laser revolvers under three moons',
+    'Alien merchants haggle over crystalline data cores',
+    'Floating colonies drift through asteroid fields'
+  ];
+
+  safeExecute(() => {
+    const generator = new RPGEventGenerator({
+      trainingData: customTrainingData,
+      theme: 'space-opera',
+      culture: 'cyberpunk'
+    });
+
+    const event = generator.generateEvent();
+    printResult('Custom theme event', event.title);
+    printResult('Description preview', event.description.substring(0, 80) + '...');
+    printResult('Training sentences used', customTrainingData.length);
+  }, 'theme creator');
 }
+
+function demoPureMarkovMode() {
+  printSection('🎲 Demo 20: Pure Markov Mode (v2.0.0)');
+
+  const pureTrainingData = [
+    'Crystal caves echo with ancient magical resonances',
+    'Shadowy figures emerge from fog-shrouded forests',
+    'Forgotten ruins hide treasures and eldritch horrors',
+    'Mysterious merchants offer artifacts of power',
+    'Wandering bards sing tales of lost civilizations'
+  ];
+
+  safeExecute(() => {
+    const pureGenerator = new RPGEventGenerator({
+      trainingData: pureTrainingData,
+      pureMarkovMode: true,
+      enableTemplates: false
+    });
+
+    const event = pureGenerator.generateEvent();
+    printResult('Pure Markov event', event.title);
+    printResult('Type', event.type);
+    printResult('Generated purely from', `${pureTrainingData.length} custom sentences`);
+    printResult('Templates disabled', 'true (Pure Markov only)');
+  }, 'pure Markov mode');
+}
+
+function demoEventEconomy() {
+  printSection('💰 Demo 21: Event Economy (v2.0.0)');
+
+  safeExecute(() => {
+    // Import the EventEconomy class
+    const EventEconomy = require('./scripts/event-economy');
+
+    // Create economy instance
+    const economy = new EventEconomy('./user-content');
+
+    // Create a sample theme
+    const sampleTheme = {
+      name: 'CyberWestern',
+      author: 'DemoCreator',
+      description: 'Cyberpunk western theme',
+      tags: ['cyberpunk', 'western', 'scifi'],
+      settings: {
+        theme: 'cyberpunk',
+        culture: 'western',
+        enableRuleEngine: true
+      },
+      trainingData: [
+        'neon signs flicker in the dusty saloon',
+        'robotic sheriffs maintain order',
+        'cyborg outlaws ride mechanical horses'
+      ],
+      customRules: [],
+      statistics: {
+        trainingSentences: 3,
+        estimatedQuality: 75
+      }
+    };
+
+    // Save the theme
+    const themePath = economy.saveTheme('CyberWestern', sampleTheme);
+    printResult('Theme saved to', themePath);
+
+    // Load the theme
+    const loadedTheme = economy.loadTheme('CyberWestern');
+    printResult('Theme loaded', loadedTheme.name);
+    printResult('Author', loadedTheme.author);
+    printResult('Training sentences', loadedTheme.trainingData.length);
+
+    // Show statistics
+    const stats = economy.getStatistics();
+    printResult('Total themes saved', stats.totalThemes);
+    printResult('Total quality score', Math.round(stats.averageThemeQuality) + '/100');
+
+  }, 'event economy');
+}
+
 runDemo();

package/dist/index.js

@@ -118,6 +118,7 @@ class RPGEventGenerator {
   /**
    * Create a new event generator
    * @param {Object} options - Configuration options
+   * @param {Chance} options.chance - Chance.js instance (optional, will create new if not provided)
    * @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'
@@ -126,11 +127,11 @@ class RPGEventGenerator {
    * @param {string} options.templateLibrary - Genre to load templates from: 'fantasy', 'sci-fi', 'horror', 'historical'
    */
   constructor(options = {}) {
-    this.chance = new Chance();
+    this.chance = options.chance || new Chance();
     this.markovGenerator = new SimpleMarkovGenerator({
       stateSize: options.stateSize || 2
     });
-    this.theme = options.theme || 'fantasy';
+    this.theme = options.theme !== undefined ? options.theme : 'fantasy';
     this.culture = options.culture;
     this.customTemplates = new Set();
     this.customChains = new Set();
@@ -139,9 +140,14 @@ class RPGEventGenerator {
     this.enableModifiers = options.enableModifiers !== false;
     this.enableRelationships = options.enableRelationships !== false;
     this.language = options.language || 'en';
-    this.enableTemplates = options.enableTemplates !== false;
-    this.templateLibrary = options.templateLibrary || null;
+    this.pureMarkovMode = options.pureMarkovMode || false;
+    this.enableTemplates = this.pureMarkovMode ? false : options.enableTemplates !== false;
+    this.templateLibrary = this.pureMarkovMode ? null : options.templateLibrary || null;
     this.loadedTemplates = new Map();
+    this.enableRuleEngine = options.enableRuleEngine !== false;
+    this.customRules = options.customRules || {};
+    this.ruleEngine = this.initializeRuleEngine();
+    this.pureMarkovMode = options.pureMarkovMode || false;
     this.initializeEnhancedFeatures(options);
     this.initializeTemplateSystem(options);
     this.initializeThemes();
@@ -934,6 +940,139 @@ class RPGEventGenerator {
    */
   generateEvent(playerContext = {}) {
     const context = this.analyzeContext(playerContext);
+    let event;
+    if (this.pureMarkovMode) {
+      event = this.generatePureMarkovEvent(context);
+    } else {
+      const template = this.selectTemplate(context);
+      const scaledChoices = this.scaleEffectsForDifficulty(this.generateContextualChoices(template.choices, context), context);
+      event = {
+        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),
+        tags: template.tags || []
+      };
+    }
+
+    // Apply custom rules if rule engine is enabled
+    if (this.enableRuleEngine) {
+      event = this.applyCustomRules(event, context);
+    }
+    return event;
+  }
+
+  /**
+   * Generate an event purely from Markov chains (v2.0.0)
+   * @param {Object} context - Generation context
+   * @returns {Object} Generated event
+   */
+  generatePureMarkovEvent(context) {
+    try {
+      const titleGenerated = this.markovGenerator.generate({
+        minLength: 15,
+        maxLength: 40,
+        maxTries: 10
+      });
+      let title = titleGenerated && titleGenerated.string ? titleGenerated.string.trim().charAt(0).toUpperCase() + titleGenerated.string.trim().slice(1) : 'Mysterious Occurrence';
+      if (title.length > 35) {
+        title = title.substring(0, 32) + '...';
+      }
+      const narrativeGenerated = this.markovGenerator.generate({
+        minLength: 50,
+        maxLength: 120,
+        maxTries: 15
+      });
+      const narrative = narrativeGenerated && narrativeGenerated.string ? narrativeGenerated.string : 'Something extraordinary has occurred that demands your attention.';
+      const descriptionGenerated = this.markovGenerator.generate({
+        minLength: 30,
+        maxLength: 80,
+        maxTries: 10
+      });
+      let description = narrative;
+      if (descriptionGenerated && descriptionGenerated.string && descriptionGenerated.string.length > 20) {
+        description = descriptionGenerated.string + '. ' + narrative.charAt(0).toLowerCase() + narrative.slice(1);
+      }
+      const choices = this.generateMarkovChoices(context);
+      return {
+        id: `event_${Date.now()}_${this.chance.guid().substring(0, 8)}`,
+        title: title,
+        description: description,
+        narrative: narrative,
+        choices: choices,
+        type: 'MARKOV_GENERATED',
+        consequence: null,
+        context: context,
+        urgency: 'normal',
+        theme: 'custom',
+        difficulty: this.calculateDifficultyTier(context.power_level || 0),
+        tags: []
+      };
+    } catch (error) {
+      console.warn('Pure Markov generation failed, falling back to template:', error.message);
+      return this.generateTemplateBasedEvent(context);
+    }
+  }
+
+  /**
+   * Generate choices for pure Markov events
+   * @param {Object} context - Generation context
+   * @returns {Array} Generated choices
+   */
+  generateMarkovChoices(context) {
+    const choiceTemplates = ['Embrace this opportunity and see where it leads', 'Approach cautiously and assess the situation', 'Seek advice from others before proceeding', 'Take immediate action to resolve the matter', 'Observe and learn from this experience', 'Decline involvement and move on', 'Investigate further to understand better', 'Trust your instincts and follow your heart'];
+    const numChoices = this.chance.integer({
+      min: 2,
+      max: 4
+    });
+    const selectedChoices = this.chance.pickset(choiceTemplates, numChoices);
+    return selectedChoices.map((text, index) => {
+      const effects = {};
+      if (this.chance.bool({
+        likelihood: 60
+      })) {
+        effects.gold = this.chance.integer({
+          min: -50,
+          max: 100
+        });
+      }
+      if (this.chance.bool({
+        likelihood: 40
+      })) {
+        effects.reputation = this.chance.integer({
+          min: -10,
+          max: 20
+        });
+      }
+      if (this.chance.bool({
+        likelihood: 30
+      })) {
+        effects.knowledge = this.chance.integer({
+          min: 5,
+          max: 25
+        });
+      }
+      return {
+        text: text,
+        effect: effects,
+        consequence: `markov_choice_${index}`
+      };
+    });
+  }
+
+  /**
+   * Fallback method for pure Markov generation failures
+   * @param {Object} context - Generation context
+   * @returns {Object} Generated event
+   */
+  generateTemplateBasedEvent(context) {
     const template = this.selectTemplate(context);
     const scaledChoices = this.scaleEffectsForDifficulty(this.generateContextualChoices(template.choices, context), context);
     return {
@@ -951,6 +1090,96 @@ class RPGEventGenerator {
     };
   }
 
+  /**
+   * Apply custom rules to an event (v2.0.0)
+   * @param {Object} event - The generated event
+   * @param {Object} context - The generation context
+   * @returns {Object} Modified event with rules applied
+   */
+  applyCustomRules(event, context) {
+    let modifiedEvent = event;
+    for (const [ruleName, rule] of Object.entries(this.customRules)) {
+      if (this.ruleEngine.evaluateRule(context, rule)) {
+        modifiedEvent = this.ruleEngine.applyRuleEffects(modifiedEvent, rule, context);
+      }
+    }
+    return modifiedEvent;
+  }
+
+  /**
+   * Add a custom rule to the rule engine (v2.0.0)
+   * @param {string} name - Unique rule name
+   * @param {Object} rule - Rule definition
+   * @param {Array} rule.conditions - Array of condition objects
+   * @param {Object} rule.effects - Effects to apply when conditions are met
+   */
+  addCustomRule(name, rule) {
+    this.customRules[name] = rule;
+  }
+
+  /**
+   * Remove a custom rule (v2.0.0)
+   * @param {string} name - Rule name to remove
+   */
+  removeCustomRule(name) {
+    if (this.customRules[name]) {
+      delete this.customRules[name];
+    }
+  }
+
+  /**
+   * Get all custom rules (v2.0.0)
+   * @returns {Object} All custom rules
+   */
+  getCustomRules() {
+    return {
+      ...this.customRules
+    };
+  }
+
+  /**
+   * Clear all custom rules (v2.0.0)
+   */
+  clearCustomRules() {
+    this.customRules = {};
+  }
+
+  /**
+   * Validate a custom rule definition (v2.0.0)
+   * @param {Object} rule - Rule to validate
+   * @returns {Object} Validation result { valid: boolean, errors: Array }
+   */
+  validateCustomRule(rule) {
+    const errors = [];
+    if (!rule || typeof rule !== 'object') {
+      errors.push('Rule must be an object');
+      return {
+        valid: false,
+        errors
+      };
+    }
+    if (rule.conditions && !Array.isArray(rule.conditions)) {
+      errors.push('Conditions must be an array');
+    }
+    if (rule.effects && typeof rule.effects !== 'object') {
+      errors.push('Effects must be an object');
+    }
+    if (rule.conditions && Array.isArray(rule.conditions)) {
+      rule.conditions.forEach((condition, index) => {
+        if (!condition.type) {
+          errors.push(`Condition ${index} missing type`);
+        }
+        if (!this.ruleEngine.conditionEvaluators[condition.type]) {
+          errors.push(`Condition ${index} has unknown type: ${condition.type}`);
+        }
+      });
+    }
+    return {
+      valid: errors.length === 0,
+      errors
+    };
+  }
+
   /**
    * Generate multiple events at once
    * @param {Object} playerContext - Player stats and state
@@ -988,6 +1217,163 @@ class RPGEventGenerator {
       this.initializeRelationshipRules();
     }
   }
+
+  /**
+   * Initialize the custom rule engine system (v2.0.0)
+   */
+  initializeRuleEngine() {
+    const ruleEngine = {
+      rules: new Map(),
+      evaluators: new Map(),
+      conditions: new Map(),
+      conditionEvaluators: {},
+      evaluateCondition: function (context, condition) {
+        const evaluator = this.conditionEvaluators[condition.type];
+        if (!evaluator) {
+          console.warn(`Unknown condition type: ${condition.type}`);
+          return false;
+        }
+        return evaluator(context, condition.params || {}, this);
+      },
+      initializeConditionEvaluators: function () {
+        const self = this;
+        this.conditionEvaluators = {
+          stat_greater_than: (context, params) => {
+            var _context$player;
+            const stat = ((_context$player = context.player) === null || _context$player === void 0 ? void 0 : _context$player[params.stat]) || context[params.stat] || 0;
+            return stat > params.value;
+          },
+          stat_less_than: (context, params) => {
+            var _context$player2;
+            const stat = ((_context$player2 = context.player) === null || _context$player2 === void 0 ? void 0 : _context$player2[params.stat]) || context[params.stat] || 0;
+            return stat < params.value;
+          },
+          stat_between: (context, params) => {
+            var _context$player3;
+            const stat = ((_context$player3 = context.player) === null || _context$player3 === void 0 ? void 0 : _context$player3[params.stat]) || context[params.stat] || 0;
+            return stat >= params.min && stat <= params.max;
+          },
+          has_item: (context, params) => {
+            var _context$player4;
+            return ((_context$player4 = context.player) === null || _context$player4 === void 0 || (_context$player4 = _context$player4.inventory) === null || _context$player4 === void 0 ? void 0 : _context$player4.includes(params.item)) || false;
+          },
+          location_is: (context, params) => {
+            return context.location === params.location;
+          },
+          season_is: (context, params) => {
+            return context.season === params.season;
+          },
+          career_is: (context, params) => {
+            var _context$player5;
+            return (((_context$player5 = context.player) === null || _context$player5 === void 0 ? void 0 : _context$player5.career) || context.career) === params.career;
+          },
+          time_greater_than: (context, params) => {
+            var _context$time;
+            return (((_context$time = context.time) === null || _context$time === void 0 ? void 0 : _context$time.day) || 0) > params.days;
+          },
+          relationship_status: (context, params) => {
+            var _context$relationship;
+            const relationship = (_context$relationship = context.relationships) === null || _context$relationship === void 0 ? void 0 : _context$relationship.find(r => r.name === params.npc);
+            if (!relationship) return false;
+            return relationship.relationship >= params.min && relationship.relationship <= params.max;
+          },
+          random_chance: (context, params) => {
+            return Math.random() < params.probability;
+          },
+          and: (context, params, ruleEngine) => {
+            return params.conditions.every(condition => ruleEngine.evaluateCondition(context, condition));
+          },
+          or: (context, params, ruleEngine) => {
+            return params.conditions.some(condition => ruleEngine.evaluateCondition(context, condition));
+          },
+          not: (context, params, ruleEngine) => {
+            return !ruleEngine.evaluateCondition(context, params.condition);
+          }
+        };
+      },
+      evaluateRule: function (context, rule) {
+        if (!rule.conditions || rule.conditions.length === 0) {
+          return true;
+        }
+        return rule.conditions.every(condition => this.evaluateCondition(context, condition));
+      },
+      applyRuleEffects: function (event, rule, context) {
+        if (!rule.effects) return event;
+        const modifiedEvent = JSON.parse(JSON.stringify(event));
+        if (rule.effects.modifyChoices) {
+          modifiedEvent.choices = modifiedEvent.choices.map(choice => ({
+            ...choice,
+            effect: this.applyEffectModifiers(choice.effect, rule.effects.modifyChoices, context)
+          }));
+        }
+        if (rule.effects.addChoices) {
+          modifiedEvent.choices = [...modifiedEvent.choices, ...rule.effects.addChoices];
+        }
+        if (rule.effects.modifyTitle) {
+          modifiedEvent.title = this.applyTextModifiers(modifiedEvent.title, rule.effects.modifyTitle, context);
+        }
+        if (rule.effects.modifyNarrative) {
+          modifiedEvent.narrative = this.applyTextModifiers(modifiedEvent.narrative, rule.effects.modifyNarrative, context);
+        }
+        if (rule.effects.setDifficulty) {
+          modifiedEvent.difficulty = rule.effects.setDifficulty;
+        }
+        if (rule.effects.addTags) {
+          if (!modifiedEvent.tags) modifiedEvent.tags = [];
+          modifiedEvent.tags = [...modifiedEvent.tags, ...rule.effects.addTags];
+        }
+        return modifiedEvent;
+      },
+      applyEffectModifiers: function (effect, modifiers, context) {
+        const modified = {
+          ...effect
+        };
+        if (modifiers.multiply) {
+          Object.keys(modifiers.multiply).forEach(key => {
+            if (modified[key] !== undefined) {
+              if (Array.isArray(modified[key])) {
+                modified[key] = modified[key].map(val => Math.round(val * modifiers.multiply[key]));
+              } else {
+                modified[key] = Math.round(modified[key] * modifiers.multiply[key]);
+              }
+            }
+          });
+        }
+        if (modifiers.add) {
+          Object.keys(modifiers.add).forEach(key => {
+            if (modified[key] !== undefined) {
+              if (Array.isArray(modified[key])) {
+                modified[key] = modified[key].map(val => val + modifiers.add[key]);
+              } else {
+                modified[key] = modified[key] + modifiers.add[key];
+              }
+            } else {
+              modified[key] = modifiers.add[key];
+            }
+          });
+        }
+        return modified;
+      },
+      applyTextModifiers: function (text, modifiers, context) {
+        let modifiedText = text;
+        if (modifiers.replace) {
+          Object.keys(modifiers.replace).forEach(pattern => {
+            const replacement = modifiers.replace[pattern];
+            modifiedText = modifiedText.replace(new RegExp(pattern, 'g'), replacement);
+          });
+        }
+        if (modifiers.append) {
+          modifiedText += modifiers.append;
+        }
+        if (modifiers.prepend) {
+          modifiedText = modifiers.prepend + modifiedText;
+        }
+        return modifiedText;
+      }
+    };
+    ruleEngine.initializeConditionEvaluators();
+    return ruleEngine;
+  }
   initializeTemplateSystem(options) {
     if (this.enableTemplates && this.templateLibrary) {
       try {
@@ -1022,7 +1408,6 @@ class RPGEventGenerator {
           }
         }
       });
-      console.log(`Loaded ${loadedCount} templates from ${genre} library`);
     } catch (error) {
       console.warn('Template loading failed:', error.message);
     }
@@ -1468,7 +1853,7 @@ class RPGEventGenerator {
             template: this.templates[stage.template]
           };
           triggeredEvents.push(event);
-          break; // Only trigger one stage per day
+          break;
         }
       }
     }
@@ -1519,7 +1904,6 @@ class RPGEventGenerator {
       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) || {}
     };
   }
@@ -2104,8 +2488,7 @@ class RPGEventGenerator {
     };
     Object.keys(adjustedWeights).forEach(templateKey => {
       const rating = challengeRatings[templateKey] || 5;
-      const powerRatio = powerLevel / 100; // Normalize power level
-
+      const powerRatio = powerLevel / 100;
       if (rating < powerRatio + 2) {
         adjustedWeights[templateKey] *= 0.5;
       } else if (rating >= powerRatio + 2 && rating <= powerRatio + 5) {
@@ -2448,7 +2831,7 @@ class RPGEventGenerator {
         break;
       case 'stress':
       case 'happiness':
-        if (context.age > 40) multiplier *= 1.1; // More emotional impact with age
+        if (context.age > 40) multiplier *= 1.1;
         break;
     }
     return multiplier;
@@ -3171,7 +3554,7 @@ class RPGEventGenerator {
    */
   getSystemStatus() {
     return {
-      version: '1.2.0',
+      version: '2.0.0',
       language: this.language,
       availableLanguages: Array.from(this.locales.keys()),
       modifiersEnabled: this.enableModifiers,