rpg-event-generator 1.2.6 → 2.0.0

package/dist/index.js

@@ -122,13 +122,15 @@ class RPGEventGenerator {
    * @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)
+   * @param {boolean} options.enableTemplates - Enable template library system (default: false)
+   * @param {string} options.templateLibrary - Genre to load templates from: 'fantasy', 'sci-fi', 'horror', 'historical'
    */
   constructor(options = {}) {
     this.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();
@@ -137,7 +139,16 @@ class RPGEventGenerator {
     this.enableModifiers = options.enableModifiers !== false;
     this.enableRelationships = options.enableRelationships !== false;
     this.language = options.language || 'en';
+    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();
     this.activeChains = new Map();
     this.chainDefinitions = this.initializeChainDefinitions();
@@ -928,6 +939,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 {
@@ -945,6 +1089,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
@@ -982,6 +1216,271 @@ 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 {
+        this.loadTemplateLibrary(this.templateLibrary);
+      } catch (error) {
+        console.warn('Failed to load template library:', error.message);
+      }
+    }
+  }
+  loadTemplateLibrary(genre) {
+    try {
+      const fs = require('fs');
+      const path = require('path');
+      const templatesDir = path.join(__dirname, '..', 'templates');
+      const genreDir = path.join(templatesDir, genre);
+      if (!fs.existsSync(genreDir)) {
+        console.warn(`Template genre '${genre}' not found`);
+        return;
+      }
+      const files = fs.readdirSync(genreDir);
+      let loadedCount = 0;
+      files.forEach(file => {
+        if (file.endsWith('.json')) {
+          try {
+            const filePath = path.join(genreDir, file);
+            const templateData = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+            const templateId = path.basename(file, '.json');
+            this.loadedTemplates.set(`${genre}:${templateId}`, templateData);
+            loadedCount++;
+          } catch (error) {
+            console.warn(`Failed to load template ${file}:`, error.message);
+          }
+        }
+      });
+    } catch (error) {
+      console.warn('Template loading failed:', error.message);
+    }
+  }
+  generateFromTemplate(templateId, context = {}) {
+    const fullTemplateId = this.templateLibrary ? `${this.templateLibrary}:${templateId}` : templateId;
+    const template = this.loadedTemplates.get(fullTemplateId);
+    if (!template) {
+      throw new Error(`Template '${fullTemplateId}' not found`);
+    }
+    const event = {
+      title: template.title,
+      description: template.narrative,
+      choices: template.choices.map(choice => ({
+        text: choice.text,
+        effect: choice.effect || {},
+        consequence: choice.consequence
+      })),
+      type: template.type,
+      difficulty: template.difficulty,
+      tags: template.tags || []
+    };
+    return this.applyContextEnhancements(event, context);
+  }
+  generateFromGenre(genre, context = {}) {
+    if (!this.loadedTemplates.size) {
+      throw new Error('No templates loaded. Call loadTemplateLibrary() first.');
+    }
+    const genreTemplates = Array.from(this.loadedTemplates.entries()).filter(([key]) => key.startsWith(`${genre}:`));
+    if (!genreTemplates.length) {
+      throw new Error(`No templates found for genre '${genre}'`);
+    }
+    const randomTemplate = this.chance.pickone(genreTemplates);
+    const template = randomTemplate[1];
+    const event = {
+      title: template.title,
+      description: template.narrative,
+      choices: template.choices.map(choice => ({
+        text: choice.text,
+        effect: choice.effect || {},
+        consequence: choice.consequence
+      })),
+      type: template.type,
+      difficulty: template.difficulty,
+      tags: template.tags || []
+    };
+    return this.applyContextEnhancements(event, context);
+  }
+  getAvailableTemplates() {
+    const templates = {};
+    this.loadedTemplates.forEach((template, key) => {
+      const [genre, id] = key.split(':');
+      if (!templates[genre]) {
+        templates[genre] = [];
+      }
+      templates[genre].push({
+        id,
+        title: template.title,
+        difficulty: template.difficulty,
+        type: template.type,
+        tags: template.tags
+      });
+    });
+    return templates;
+  }
+  applyContextEnhancements(event, context) {
+    if (context.player) {
+      event.playerContext = context.player;
+    }
+    if (context.environment) {
+      event.environment = context.environment;
+    }
+    return event;
+  }
   initializeThemes() {
     this.themes = {
       fantasy: ['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', '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', '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', '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', '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', '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', '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', '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', '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', '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', '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'],
@@ -1353,7 +1852,7 @@ class RPGEventGenerator {
             template: this.templates[stage.template]
           };
           triggeredEvents.push(event);
-          break; // Only trigger one stage per day
+          break;
         }
       }
     }
@@ -1404,7 +1903,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) || {}
     };
   }
@@ -1989,8 +2487,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) {
@@ -2333,7 +2830,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;
@@ -3056,7 +3553,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,

package/package.json

@@ -1,10 +1,12 @@
 {
   "name": "rpg-event-generator",
-  "version": "1.2.6",
-  "description": "Procedural RPG event generation system for games",
+  "version": "2.0.0",
+  "description": "RPG Event Generator v2.0.0 - Complete procedural event generation with 429+ templates, rule engine, and theme creator",
   "main": "dist/index.js",
   "files": [
     "dist/",
+    "templates/",
+    "scripts/",
     "demo.js",
     "README.md",
     "LICENSE"
@@ -12,7 +14,14 @@
   "scripts": {
     "test": "jest",
     "build": "babel src --out-dir dist",
-    "prepublishOnly": "npm run build"
+    "build:browser": "npm run build && browserify dist/index.js --standalone RPGEventGenerator -o demo-web/rpg-event-generator.js",
+    "prepublishOnly": "npm run build",
+    "demo": "node demo.js",
+    "economy:list": "node scripts/event-economy.js list-themes",
+    "economy:stats": "node scripts/event-economy.js stats",
+    "export:unity": "node scripts/export-templates.js unity",
+    "export:godot": "node scripts/export-templates.js godot",
+    "export:typescript": "node scripts/export-templates.js typescript"
   },
   "keywords": [
     "rpg",
@@ -54,6 +63,7 @@
     "@babel/cli": "^7.23.0",
     "@babel/core": "^7.23.0",
     "@babel/preset-env": "^7.23.0",
+    "browserify": "^17.0.0",
     "jest": "^29.7.0",
     "jest-environment-node": "^29.7.0"
   },
@@ -63,6 +73,10 @@
       "^.+\\.(js|jsx)$": "babel-jest"
     }
   },
+  "bin": {
+    "rpg-events": "./scripts/event-economy.js",
+    "rpg-export": "./scripts/export-templates.js"
+  },
   "engines": {
     "node": ">=14.0.0"
   }