rpg-event-generator 4.0.0 → 4.0.1

package/dist/world/WorldBuildingSystem.js

@@ -1,26 +1,48 @@
 "use strict";
-// RPG Event Generator v3.0.0 - World Building System
-// Automated world generation, faction management, and historical event simulation
+// RPG Event Generator v4.0.0 - World Building System
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WorldBuildingSystem = void 0;
+const chance_1 = require("chance");
+const worldContent_1 = require("./worldContent");
 class WorldBuildingSystem {
     constructor() {
         this.regions = new Map();
         this.factions = new Map();
         this.historicalEvents = [];
         this.currentYear = 1000;
-    }
-    generateWorld(seed) {
-        const regions = this.generateRegions(seed);
+        this.historyStartYear = 800;
+        this.chance = new chance_1.Chance();
+        this.landmarkCounter = 0;
+    }
+    generateWorld(seedOrOptions) {
+        const options = this.normalizeOptions(seedOrOptions);
+        this.regions.clear();
+        this.factions.clear();
+        this.historicalEvents = [];
+        this.currentYear = options.currentYear ?? 1000;
+        this.historyStartYear = options.historyStartYear ?? 800;
+        this.landmarkCounter = 0;
+        this.chance = options.seed !== undefined ? new chance_1.Chance(options.seed) : new chance_1.Chance();
+        const regions = this.generateRegions(options.continentCount ?? 5);
         const factions = this.generateFactions(regions);
+        this.initializeRelationships(factions, regions);
         const events = this.generateInitialHistory(regions, factions);
+        this.historicalEvents.push(...events);
         return { regions, factions, events };
     }
-    generateRegions(seed) {
+    normalizeOptions(seedOrOptions) {
+        if (typeof seedOrOptions === 'number') {
+            return { seed: seedOrOptions };
+        }
+        return seedOrOptions ?? {};
+    }
+    generateRegions(continentCount) {
         const regions = [];
-        const continentNames = ['Eldoria', 'Drakoria', 'Sylvoria', 'Aquilon', 'Ignisia'];
-        const kingdomNames = ['Northern Realms', 'Southern Kingdoms', 'Eastern Empire', 'Western Isles', 'Central Dominion'];
-        continentNames.forEach((name, i) => {
+        const count = Math.max(2, Math.min(8, continentCount));
+        const continents = this.chance.pickset(worldContent_1.CONTINENT_NAMES, count);
+        continents.forEach((name, i) => {
+            const culture = this.chance.pickone(['Human', 'Elven', 'Dwarven', 'Orcish']);
+            const climate = this.chance.pickone(['temperate', 'tropical', 'arctic', 'desert']);
             const continent = {
                 id: `continent_${i}`,
                 name,
@@ -28,26 +50,35 @@ class WorldBuildingSystem {
                 sub_regions: [],
                 landmarks: [],
                 resources: [],
-                population: Math.floor(Math.random() * 10000000) + 5000000,
-                culture: ['Human', 'Elven', 'Dwarven', 'Orcish'][Math.floor(Math.random() * 4)],
-                climate: ['temperate', 'tropical', 'arctic', 'desert'][Math.floor(Math.random() * 4)],
-                political_stability: Math.random() * 0.8 + 0.2,
-                economic_prosperity: Math.random() * 0.8 + 0.2
+                population: this.chance.integer({ min: 5000000, max: 14999999 }),
+                culture,
+                climate,
+                political_stability: this.chance.floating({ min: 0.2, max: 1.0 }),
+                economic_prosperity: this.chance.floating({ min: 0.2, max: 1.0 })
             };
-            for (let j = 0; j < 2 + Math.floor(Math.random() * 3); j++) {
+            const kingdomCount = this.chance.integer({ min: 2, max: 4 });
+            const usedPrefixes = new Set();
+            for (let j = 0; j < kingdomCount; j++) {
+                let prefix = this.chance.pickone(worldContent_1.KINGDOM_PREFIXES);
+                while (usedPrefixes.has(prefix) && usedPrefixes.size < worldContent_1.KINGDOM_PREFIXES.length) {
+                    prefix = this.chance.pickone(worldContent_1.KINGDOM_PREFIXES);
+                }
+                usedPrefixes.add(prefix);
+                const suffix = this.chance.pickone(worldContent_1.KINGDOM_SUFFIXES);
+                const kingdomId = `kingdom_${i}_${j}`;
                 const kingdom = {
-                    id: `kingdom_${i}_${j}`,
-                    name: `${kingdomNames[j % kingdomNames.length]} of ${name}`,
+                    id: kingdomId,
+                    name: `${prefix} ${suffix} of ${name}`,
                     type: 'kingdom',
                     parent_region: continent.id,
                     sub_regions: [],
-                    landmarks: this.generateLandmarks(2 + Math.floor(Math.random() * 3)),
-                    resources: this.generateResources(3 + Math.floor(Math.random() * 4)),
-                    population: Math.floor(Math.random() * 2000000) + 500000,
-                    culture: continent.culture,
-                    climate: continent.climate,
-                    political_stability: Math.max(0.1, continent.political_stability + (Math.random() - 0.5) * 0.4),
-                    economic_prosperity: Math.max(0.1, continent.economic_prosperity + (Math.random() - 0.5) * 0.4)
+                    landmarks: this.generateLandmarks(this.chance.integer({ min: 2, max: 4 }), kingdomId, climate, culture),
+                    resources: this.generateResources(this.chance.integer({ min: 3, max: 6 }), climate),
+                    population: this.chance.integer({ min: 500000, max: 2499999 }),
+                    culture,
+                    climate,
+                    political_stability: Math.max(0.1, continent.political_stability + this.chance.floating({ min: -0.2, max: 0.2 })),
+                    economic_prosperity: Math.max(0.1, continent.economic_prosperity + this.chance.floating({ min: -0.2, max: 0.2 }))
                 };
                 continent.sub_regions.push(kingdom.id);
                 regions.push(kingdom);
@@ -57,68 +88,128 @@ class WorldBuildingSystem {
         regions.forEach(region => this.regions.set(region.id, region));
         return Array.from(this.regions.values());
     }
-    generateLandmarks(count) {
-        const landmarkTypes = ['castle', 'temple', 'ruins', 'mountain', 'forest', 'lake', 'monument'];
+    generateLandmarks(count, regionId, climate, culture) {
+        const landmarkTypes = [
+            'castle', 'temple', 'ruins', 'mountain', 'forest', 'lake', 'monument'
+        ];
         const landmarks = [];
         for (let i = 0; i < count; i++) {
+            const type = this.chance.pickone(landmarkTypes);
+            const adjective = this.chance.pickone(worldContent_1.LANDMARK_ADJECTIVES);
+            const noun = this.chance.pickone(worldContent_1.LANDMARK_NOUNS[type]);
+            const id = `landmark_${regionId}_${this.landmarkCounter++}`;
             landmarks.push({
-                id: `landmark_${i}`,
-                name: `Ancient ${landmarkTypes[i % landmarkTypes.length].charAt(0).toUpperCase() + landmarkTypes[i % landmarkTypes.length].slice(1)}`,
-                type: landmarkTypes[i % landmarkTypes.length],
-                significance: Math.random() * 10,
-                description: `A significant ${landmarkTypes[i % landmarkTypes.length]} with historical importance.`,
-                discovered: Math.random() > 0.3
+                id,
+                name: `${adjective} ${noun}`,
+                type,
+                significance: this.chance.floating({ min: 0, max: 10 }),
+                description: `A ${adjective.toLowerCase()} ${type} sacred to ${culture} folk in the ${climate} lands.`,
+                discovered: this.chance.bool({ likelihood: 70 })
             });
         }
         return landmarks;
     }
-    generateResources(count) {
-        const resourceTypes = ['gold', 'iron', 'wood', 'grain', 'magic_crystals', 'herbs'];
+    generateResources(count, climate) {
+        const pool = worldContent_1.CLIMATE_RESOURCES[climate] ?? worldContent_1.CLIMATE_RESOURCES.temperate;
+        const resourceTypes = pool;
         const resources = [];
+        const used = new Set();
         for (let i = 0; i < count; i++) {
+            let type = this.chance.pickone(resourceTypes);
+            let attempts = 0;
+            while (used.has(type) && attempts < 10) {
+                type = this.chance.pickone(resourceTypes);
+                attempts++;
+            }
+            used.add(type);
             resources.push({
-                type: resourceTypes[i % resourceTypes.length],
-                abundance: Math.random() * 10,
-                quality: Math.random() * 10
+                type,
+                abundance: this.chance.floating({ min: 0, max: 10 }),
+                quality: this.chance.floating({ min: 0, max: 10 })
             });
         }
         return resources;
     }
     generateFactions(regions) {
         const factions = [];
-        const factionTypes = ['kingdom', 'guild', 'cult', 'tribe', 'merchants', 'nobles'];
-        regions.filter(r => r.type === 'kingdom').forEach((kingdom, i) => {
+        const factionTypes = [
+            'kingdom', 'guild', 'cult', 'tribe', 'merchants', 'nobles'
+        ];
+        regions
+            .filter(r => r.type === 'kingdom')
+            .forEach((kingdom, i) => {
+            const type = factionTypes[i % factionTypes.length];
             const faction = {
                 id: `faction_${i}`,
-                name: `${kingdom.name} ${factionTypes[i % factionTypes.length].charAt(0).toUpperCase() + factionTypes[i % factionTypes.length].slice(1)}`,
-                type: factionTypes[i % factionTypes.length],
-                leader: `Leader of ${kingdom.name}`,
+                name: this.generateFactionName(type, kingdom),
+                type,
+                leader: this.generateLeaderName(kingdom.culture, kingdom.name),
                 home_region: kingdom.id,
-                influence: Math.random() * 10,
-                reputation: Math.random() * 10 - 5,
+                influence: this.chance.floating({ min: 0, max: 10 }),
+                reputation: this.chance.floating({ min: -5, max: 5 }),
                 resources: {
-                    gold: Math.floor(Math.random() * 10000),
-                    influence: Math.floor(Math.random() * 100)
+                    gold: this.chance.integer({ min: 0, max: 9999 }),
+                    influence: this.chance.integer({ min: 0, max: 99 })
                 },
                 relationships: {},
-                goals: ['Expand territory', 'Increase wealth', 'Gain political power']
+                goals: this.chance.pickset(worldContent_1.FACTION_GOALS[type] ?? worldContent_1.FACTION_GOALS.kingdom, 2)
             };
             factions.push(faction);
         });
+        return factions;
+    }
+    generateFactionName(type, kingdom) {
+        const shortName = kingdom.name.split(' of ')[0];
+        switch (type) {
+            case 'kingdom':
+                return kingdom.name;
+            case 'guild':
+                return `The ${this.chance.pickone(worldContent_1.LANDMARK_ADJECTIVES)} ${this.chance.pickone(['Smiths', 'Arcane', 'Shipwrights', 'Healers'])} Guild`;
+            case 'cult':
+                return `Cult of ${this.chance.pickone(worldContent_1.CULT_DEITIES)}`;
+            case 'tribe':
+                return `${shortName} ${this.chance.pickone(['Clans', 'Horde', 'Kin', 'People'])}`;
+            case 'merchants':
+                return `${shortName} Merchant League`;
+            case 'nobles':
+                return `House ${this.chance.pickone(worldContent_1.LEADER_NAMES)} of ${kingdom.name.split(' of ')[1] ?? kingdom.name}`;
+            default:
+                return kingdom.name;
+        }
+    }
+    generateLeaderName(culture, realm) {
+        const titles = worldContent_1.LEADER_TITLES[culture] ?? worldContent_1.LEADER_TITLES.Human;
+        const title = this.chance.pickone(titles);
+        const name = this.chance.pickone(worldContent_1.LEADER_NAMES);
+        return `${title} ${name} of ${realm.split(' of ')[0]}`;
+    }
+    initializeRelationships(factions, regions) {
         factions.forEach(faction => {
-            factions.forEach(otherFaction => {
-                if (faction.id !== otherFaction.id) {
-                    faction.relationships[otherFaction.id] = Math.random() * 10 - 5;
+            factions.forEach(other => {
+                if (faction.id === other.id)
+                    return;
+                let relationship = this.chance.floating({ min: -5, max: 5 });
+                if (this.areNeighborFactions(faction, other, regions)) {
+                    relationship = this.chance.bool({ likelihood: 45 })
+                        ? this.chance.floating({ min: -5, max: -0.5 })
+                        : this.chance.floating({ min: 0.5, max: 5 });
                 }
+                faction.relationships[other.id] = relationship;
             });
             this.factions.set(faction.id, faction);
         });
-        return Array.from(this.factions.values());
+    }
+    areNeighborFactions(a, b, regions) {
+        const regionA = regions.find(r => r.id === a.home_region);
+        const regionB = regions.find(r => r.id === b.home_region);
+        if (!regionA || !regionB)
+            return false;
+        return regionA.parent_region === regionB.parent_region && regionA.id !== regionB.id;
     }
     generateInitialHistory(regions, factions) {
         const events = [];
-        for (let year = 800; year <= this.currentYear; year += 50 + Math.floor(Math.random() * 100)) {
-            if (Math.random() > 0.7) {
+        for (let year = this.historyStartYear; year <= this.currentYear; year += 50 + this.chance.integer({ min: 0, max: 99 })) {
+            if (this.chance.bool({ likelihood: 30 })) {
                 const event = this.generateHistoricalEvent(year, regions, factions);
                 events.push(event);
                 this.applyHistoricalConsequences(event);
@@ -127,78 +218,126 @@ class WorldBuildingSystem {
         return events;
     }
     generateHistoricalEvent(year, regions, factions) {
-        const eventTypes = ['war', 'alliance', 'discovery', 'disaster', 'ascension', 'fall', 'plague', 'famine', 'revolution', 'invasion', 'treaty', 'betrayal'];
-        const eventType = eventTypes[Math.floor(Math.random() * eventTypes.length)];
-        const numFactions = Math.max(1, Math.min(4, Math.floor(Math.random() * 3) + 1));
-        const involvedFactions = factions
-            .sort(() => Math.random() - 0.5)
-            .slice(0, numFactions);
+        const eventTypes = [
+            'war', 'alliance', 'discovery', 'disaster', 'ascension', 'fall',
+            'plague', 'famine', 'revolution', 'invasion', 'treaty', 'betrayal'
+        ];
+        const eventType = this.chance.pickone(eventTypes);
+        const involvedFactions = this.pickFactionsForEvent(eventType, factions);
         const affectedRegions = regions
-            .filter(r => involvedFactions.some(f => f.home_region === r.id || r.sub_regions.includes(f.home_region)))
+            .filter(r => r.type === 'kingdom' &&
+            involvedFactions.some(f => f.home_region === r.id))
             .map(r => r.id);
+        const primaryRegion = regions.find(r => r.id === involvedFactions[0]?.home_region);
         const event = {
-            id: `event_${year}_${Math.random().toString(36).substr(2, 9)}`,
+            id: `event_${year}_${this.chance.string({ length: 9, pool: 'abcdefghijklmnopqrstuvwxyz0123456789' })}`,
             year,
-            title: this.generateEventTitle(eventType, involvedFactions),
-            description: this.generateEventDescription(eventType, involvedFactions),
+            title: this.generateEventTitle(eventType, involvedFactions, primaryRegion),
+            description: this.generateEventDescription(eventType, involvedFactions, primaryRegion),
             type: eventType,
-            regions_affected: affectedRegions,
+            regions_affected: affectedRegions.length > 0 ? affectedRegions : involvedFactions.map(f => f.home_region),
             factions_involved: involvedFactions.map(f => f.id),
-            consequences: this.generateAdvancedConsequences(eventType, involvedFactions, affectedRegions, regions),
-            significance: this.calculateEventSignificance(eventType, involvedFactions.length, affectedRegions.length)
+            consequences: this.generateAdvancedConsequences(eventType, involvedFactions, affectedRegions.length > 0 ? affectedRegions : involvedFactions.map(f => f.home_region), regions),
+            significance: this.calculateEventSignificance(eventType, involvedFactions.length, Math.max(1, affectedRegions.length))
         };
         return event;
     }
-    generateEventTitle(type, factions) {
-        const factionName = factions[0]?.name || 'Unknown';
-        const secondaryFaction = factions[1]?.name || 'Unknown';
-        switch (type) {
-            case 'war': return factions.length > 1 ? `${factionName} vs ${secondaryFaction} War` : `${factionName} Conquest`;
-            case 'alliance': return `${factionName} Alliance`;
-            case 'discovery': return `${factionName} Discovery`;
-            case 'disaster': return `${factionName} Disaster`;
-            case 'ascension': return `${factionName} Ascension`;
-            case 'fall': return `${factionName} Fall`;
-            case 'plague': return `The ${factionName} Plague`;
-            case 'famine': return `${factionName} Famine`;
-            case 'revolution': return `${factionName} Revolution`;
-            case 'invasion': return `${factionName} Invasion`;
-            case 'treaty': return `${factionName} Treaty`;
-            case 'betrayal': return factions.length > 1 ? `${factionName} Betrays ${secondaryFaction}` : `${factionName} Betrayal`;
-            default: return `${factionName} Event`;
+    pickFactionsForEvent(eventType, factions) {
+        if (factions.length === 0)
+            return [];
+        if (factions.length === 1)
+            return [factions[0]];
+        const shuffled = this.chance.shuffle([...factions]);
+        const pairTypes = [
+            'war', 'alliance', 'betrayal', 'treaty', 'invasion'
+        ];
+        if (!pairTypes.includes(eventType)) {
+            return [this.chance.pickone(shuffled)];
+        }
+        if (['war', 'invasion', 'betrayal'].includes(eventType)) {
+            for (const faction of shuffled) {
+                const enemies = Object.entries(faction.relationships)
+                    .filter(([_, value]) => value < -1)
+                    .map(([id]) => this.factions.get(id))
+                    .filter((f) => !!f);
+                if (enemies.length > 0) {
+                    return [faction, this.chance.pickone(enemies)];
+                }
+            }
+        }
+        if (['alliance', 'treaty'].includes(eventType)) {
+            for (const faction of shuffled) {
+                const allies = Object.entries(faction.relationships)
+                    .filter(([_, value]) => value > 1)
+                    .map(([id]) => this.factions.get(id))
+                    .filter((f) => !!f);
+                if (allies.length > 0) {
+                    return [faction, this.chance.pickone(allies)];
+                }
+            }
         }
+        return shuffled.slice(0, 2);
     }
-    generateEventDescription(type, factions) {
-        const factionName = factions[0]?.name || 'Unknown';
-        const secondaryFaction = factions[1]?.name || 'Unknown';
+    generateEventTitle(type, factions, region) {
+        const place = region?.name ?? factions[0]?.name ?? 'Unknown';
+        const factionA = factions[0]?.name ?? 'Unknown';
+        const factionB = factions[1]?.name ?? 'Unknown';
         switch (type) {
-            case 'war': return factions.length > 1 ?
-                `${factionName} and ${secondaryFaction} clashed in a brutal conflict that lasted for years, with neither side gaining a decisive victory.` :
-                `${factionName} waged war against neighboring territories, conquering new lands and expanding their influence.`;
-            case 'alliance': return `${factionName} formed a powerful alliance with neighboring factions, creating a bloc that dominated regional politics.`;
-            case 'discovery': return `${factionName} made groundbreaking discoveries in ancient ruins, unlocking powerful artifacts and knowledge.`;
-            case 'disaster': return `A catastrophic disaster struck ${factionName}, destroying infrastructure and claiming countless lives.`;
-            case 'ascension': return `Through cunning diplomacy and military prowess, ${factionName} rose from obscurity to become a major power.`;
-            case 'fall': return `${factionName} suffered a dramatic decline due to corruption, military defeats, and economic collapse.`;
-            case 'plague': return `A devastating plague swept through ${factionName}'s territories, decimating the population and weakening their society.`;
-            case 'famine': return `Severe famine gripped ${factionName}, causing widespread starvation and social unrest.`;
-            case 'revolution': return `The people of ${factionName} rose up in revolution, overthrowing the ruling class and establishing a new order.`;
-            case 'invasion': return `${factionName} suffered a devastating invasion that destroyed their armies and occupied their lands.`;
-            case 'treaty': return `${factionName} negotiated a historic treaty that brought peace and prosperity to the region.`;
-            case 'betrayal': return factions.length > 1 ?
-                `${factionName} betrayed their longtime ally ${secondaryFaction}, shattering trust and igniting new conflicts.` :
-                `${factionName} suffered a catastrophic betrayal from within their own ranks.`;
-            default: return `${factionName} experienced a significant historical event that shaped their destiny.`;
+            case 'war':
+                return factions.length > 1 ? `War of ${place}` : `${factionA} Conquest`;
+            case 'alliance':
+                return `Pact of ${place}`;
+            case 'discovery':
+                return `Discovery at ${place}`;
+            case 'disaster':
+                return `Calamity in ${place}`;
+            case 'ascension':
+                return `Rise of ${factionA}`;
+            case 'fall':
+                return `Fall of ${factionA}`;
+            case 'plague':
+                return `Plague of ${place}`;
+            case 'famine':
+                return `Famine in ${place}`;
+            case 'revolution':
+                return `Revolt in ${place}`;
+            case 'invasion':
+                return `Invasion of ${place}`;
+            case 'treaty':
+                return `Treaty of ${place}`;
+            case 'betrayal':
+                return factions.length > 1 ? `${factionA} Betrays ${factionB}` : `Betrayal at ${place}`;
+            default:
+                return `${place} Turning Point`;
+        }
+    }
+    generateEventDescription(type, factions, region) {
+        const templates = worldContent_1.HISTORICAL_TEMPLATES[type];
+        const template = templates ? this.chance.pickone(templates) : null;
+        const landmark = region?.landmarks?.length
+            ? this.chance.pickone(region.landmarks).name
+            : 'a border fort';
+        const vars = {
+            factionA: factions[0]?.name ?? 'Unknown',
+            factionB: factions[1]?.name ?? 'a rival power',
+            region: region?.name ?? 'the borderlands',
+            landmark,
+            climate: region?.climate ?? 'temperate',
+            culture: region?.culture ?? 'Human'
+        };
+        if (template) {
+            return (0, worldContent_1.formatTemplate)(template, vars);
         }
+        return `${vars.factionA} shaped the fate of ${vars.region} near ${vars.landmark}.`;
     }
     generateConsequences(type, factions, regions) {
         const allRegions = Array.from(this.regions.values());
         return this.generateAdvancedConsequences(type, factions, regions, allRegions);
     }
-    generateAdvancedConsequences(eventType, factions, regions, allRegions) {
+    generateAdvancedConsequences(eventType, factions, regionIds, allRegions) {
         const consequences = [];
         factions.forEach(faction => {
-            const baseChange = Math.random() - 0.5;
+            const baseChange = this.chance.floating({ min: -0.5, max: 0.5 });
             switch (eventType) {
                 case 'war':
                     consequences.push({
@@ -238,7 +377,7 @@ class WorldBuildingSystem {
                         target_id: faction.id,
                         property: 'resources.gold',
                         old_value: faction.resources.gold,
-                        new_value: faction.resources.gold + Math.floor(Math.random() * 10000)
+                        new_value: faction.resources.gold + this.chance.integer({ min: 0, max: 9999 })
                     });
                     consequences.push({
                         type: 'faction_change',
@@ -250,10 +389,10 @@ class WorldBuildingSystem {
                     break;
                 case 'disaster':
                 case 'plague':
-                case 'famine':
+                case 'famine': {
                     const populationRegion = allRegions.find(r => r.id === faction.home_region);
                     if (populationRegion) {
-                        const populationLoss = Math.floor(populationRegion.population * (0.05 + Math.random() * 0.15));
+                        const populationLoss = Math.floor(populationRegion.population * (0.05 + this.chance.floating({ min: 0, max: 0.15 })));
                         consequences.push({
                             type: 'region_change',
                             target_id: faction.home_region,
@@ -270,6 +409,7 @@ class WorldBuildingSystem {
                         new_value: Math.max(0, faction.influence - Math.abs(baseChange) * 3)
                     });
                     break;
+                }
                 case 'revolution':
                     consequences.push({
                         type: 'faction_change',
@@ -290,9 +430,8 @@ class WorldBuildingSystem {
                     break;
             }
         });
-        // Add regional consequences for certain events
         if (['disaster', 'plague', 'famine', 'invasion'].includes(eventType)) {
-            regions.forEach(regionId => {
+            regionIds.forEach(regionId => {
                 const region = allRegions.find(r => r.id === regionId);
                 if (region) {
                     consequences.push({
@@ -300,17 +439,37 @@ class WorldBuildingSystem {
                         target_id: regionId,
                         property: 'political_stability',
                         old_value: region.political_stability,
-                        new_value: Math.max(0.1, region.political_stability - Math.random() * 0.3)
+                        new_value: Math.max(0.1, region.political_stability - this.chance.floating({ min: 0, max: 0.3 }))
                     });
                 }
             });
         }
+        if (['alliance', 'treaty'].includes(eventType) && factions.length > 1) {
+            const [a, b] = factions;
+            consequences.push({
+                type: 'relationship_change',
+                target_id: a.id,
+                property: b.id,
+                old_value: a.relationships[b.id],
+                new_value: Math.min(10, (a.relationships[b.id] ?? 0) + 2)
+            });
+        }
+        if (['war', 'betrayal', 'invasion'].includes(eventType) && factions.length > 1) {
+            const [a, b] = factions;
+            consequences.push({
+                type: 'relationship_change',
+                target_id: a.id,
+                property: b.id,
+                old_value: a.relationships[b.id],
+                new_value: Math.max(-10, (a.relationships[b.id] ?? 0) - 2)
+            });
+        }
         return consequences;
     }
     applyHistoricalConsequences(event) {
         event.consequences.forEach(consequence => {
             switch (consequence.type) {
-                case 'faction_change':
+                case 'faction_change': {
                     const faction = this.factions.get(consequence.target_id);
                     if (faction) {
                         if (consequence.property.includes('.')) {
@@ -324,15 +483,54 @@ class WorldBuildingSystem {
                         }
                     }
                     break;
-                case 'region_change':
+                }
+                case 'region_change': {
                     const region = this.regions.get(consequence.target_id);
                     if (region) {
                         region[consequence.property] = consequence.new_value;
                     }
                     break;
+                }
+                case 'relationship_change': {
+                    const faction = this.factions.get(consequence.target_id);
+                    const partner = this.factions.get(consequence.property);
+                    if (faction && partner) {
+                        faction.relationships[partner.id] = consequence.new_value;
+                        partner.relationships[faction.id] = consequence.new_value;
+                    }
+                    break;
+                }
             }
         });
     }
+    /** Find a kingdom or region whose name matches the given location string. */
+    findRegionByLocation(location) {
+        if (!location)
+            return undefined;
+        const query = location.toLowerCase();
+        return Array.from(this.regions.values()).find(r => r.name.toLowerCase().includes(query) || r.id.toLowerCase() === query);
+    }
+    /** One-sentence lore hook for a player location — useful when layering world context onto events. */
+    getLoreSnippet(location) {
+        const region = this.findRegionByLocation(location);
+        if (!region)
+            return null;
+        const regionalEvents = this.historicalEvents
+            .filter(e => e.regions_affected.includes(region.id))
+            .sort((a, b) => b.year - a.year);
+        if (regionalEvents.length === 0) {
+            const faction = Array.from(this.factions.values()).find(f => f.home_region === region.id);
+            if (faction) {
+                if (faction.name === region.name) {
+                    return `${region.name} is ruled by ${faction.leader}.`;
+                }
+                return `${region.name} is held by ${faction.name}, led by ${faction.leader}.`;
+            }
+            return `${region.name} is a ${region.climate} ${region.type} of the ${region.culture} peoples.`;
+        }
+        const latest = regionalEvents[0];
+        return `In ${latest.year}, ${latest.title.toLowerCase()} — ${latest.description}`;
+    }
     getRegion(id) {
         return this.regions.get(id);
     }
@@ -350,10 +548,12 @@ class WorldBuildingSystem {
     }
     simulateYears(years) {
         const newEvents = [];
+        const regions = Array.from(this.regions.values());
+        const factions = Array.from(this.factions.values());
         for (let i = 0; i < years; i++) {
             this.currentYear++;
-            if (Math.random() > 0.8) {
-                const event = this.generateHistoricalEvent(this.currentYear, Array.from(this.regions.values()), Array.from(this.factions.values()));
+            if (this.chance.bool({ likelihood: 20 })) {
+                const event = this.generateHistoricalEvent(this.currentYear, regions, factions);
                 newEvents.push(event);
                 this.historicalEvents.push(event);
                 this.applyHistoricalConsequences(event);
@@ -398,16 +598,12 @@ class WorldBuildingSystem {
         if (!faction)
             return 0;
         let influence = faction.influence;
-        // Add influence from allies
-        const allies = this.getFactionAllies(factionId);
-        allies.forEach(allyId => {
+        this.getFactionAllies(factionId).forEach(allyId => {
             const ally = this.factions.get(allyId);
             if (ally)
                 influence += ally.influence * 0.3;
         });
-        // Subtract influence from enemies
-        const enemies = this.getFactionEnemies(factionId);
-        enemies.forEach(enemyId => {
+        this.getFactionEnemies(factionId).forEach(enemyId => {
             const enemy = this.factions.get(enemyId);
             if (enemy)
                 influence -= enemy.influence * 0.2;
@@ -419,30 +615,32 @@ class WorldBuildingSystem {
         if (!faction)
             return [];
         const routes = [];
+        const types = ['goods', 'resources', 'magic', 'information'];
         Object.entries(faction.relationships).forEach(([partnerId, relationship]) => {
             if (relationship > 0) {
                 const partner = this.factions.get(partnerId);
                 if (partner) {
-                    const volume = Math.floor((relationship + 5) * 10);
-                    const types = ['goods', 'resources', 'magic', 'information'];
-                    const type = types[Math.floor(Math.random() * types.length)];
-                    routes.push({ partner: partner.name, volume, type });
+                    routes.push({
+                        partner: partner.name,
+                        volume: Math.floor((relationship + 5) * 10),
+                        type: this.chance.pickone(types)
+                    });
                 }
             }
         });
         return routes;
     }
     getFactionPowerRanking() {
-        const rankings = Array.from(this.factions.values()).map(faction => ({
+        return Array.from(this.factions.values())
+            .map(faction => ({
             factionId: faction.id,
             name: faction.name,
             power: this.calculateFactionInfluence(faction.id) + faction.resources.gold * 0.01
-        }));
-        return rankings.sort((a, b) => b.power - a.power);
+        }))
+            .sort((a, b) => b.power - a.power);
     }
     getFactionGoals(factionId) {
-        const faction = this.factions.get(factionId);
-        return faction?.goals || [];
+        return this.factions.get(factionId)?.goals ?? [];
     }
     updateFactionRelationship(factionId1, factionId2, change) {
         const faction1 = this.factions.get(factionId1);
@@ -459,17 +657,23 @@ class WorldBuildingSystem {
         if (!faction)
             return null;
         const network = {
-            faction: faction,
+            faction,
             allies: [],
             enemies: [],
             neutrals: []
         };
         if (depth > 0) {
-            network.allies = this.getFactionAllies(factionId).map(id => this.getFactionNetwork(id, depth - 1)).filter(Boolean);
-            network.enemies = this.getFactionEnemies(factionId).map(id => this.getFactionNetwork(id, depth - 1)).filter(Boolean);
-            const allRelationships = Object.keys(faction.relationships);
-            const alliesAndEnemies = new Set([...network.allies.map((f) => f.faction.id), ...network.enemies.map((f) => f.faction.id)]);
-            network.neutrals = allRelationships
+            network.allies = this.getFactionAllies(factionId)
+                .map(id => this.getFactionNetwork(id, depth - 1))
+                .filter(Boolean);
+            network.enemies = this.getFactionEnemies(factionId)
+                .map(id => this.getFactionNetwork(id, depth - 1))
+                .filter(Boolean);
+            const alliesAndEnemies = new Set([
+                ...network.allies.map((f) => f.faction.id),
+                ...network.enemies.map((f) => f.faction.id)
+            ]);
+            network.neutrals = Object.keys(faction.relationships)
                 .filter(id => !alliesAndEnemies.has(id))
                 .map(id => this.factions.get(id))
                 .filter(Boolean);
@@ -479,34 +683,32 @@ class WorldBuildingSystem {
     calculateEventSignificance(eventType, factionCount, regionCount) {
         let baseSignificance = 5;
         const typeMultipliers = {
-            'war': 8,
-            'alliance': 6,
-            'discovery': 7,
-            'disaster': 9,
-            'plague': 10,
-            'revolution': 9,
-            'invasion': 8,
-            'fall': 7,
-            'ascension': 7,
-            'treaty': 5,
-            'betrayal': 6,
-            'famine': 7
+            war: 8,
+            alliance: 6,
+            discovery: 7,
+            disaster: 9,
+            plague: 10,
+            revolution: 9,
+            invasion: 8,
+            fall: 7,
+            ascension: 7,
+            treaty: 5,
+            betrayal: 6,
+            famine: 7
         };
         baseSignificance *= typeMultipliers[eventType] || 5;
-        baseSignificance *= (1 + (factionCount - 1) * 0.5);
-        baseSignificance *= (1 + (regionCount - 1) * 0.3);
-        return Math.min(10, Math.max(1, baseSignificance + (Math.random() - 0.5) * 2));
+        baseSignificance *= 1 + (factionCount - 1) * 0.5;
+        baseSignificance *= 1 + (regionCount - 1) * 0.3;
+        return Math.min(10, Math.max(1, baseSignificance + this.chance.floating({ min: -1, max: 1 })));
     }
     getRegionResources(regionId) {
-        const region = this.regions.get(regionId);
-        return region?.resources || [];
+        return this.regions.get(regionId)?.resources ?? [];
     }
     getWorldStats() {
         const regions = Array.from(this.regions.values());
-        const factions = Array.from(this.factions.values());
         return {
             totalRegions: regions.length,
-            totalFactions: factions.length,
+            totalFactions: this.factions.size,
             totalHistoricalEvents: this.historicalEvents.length,
             averageStability: regions.reduce((sum, r) => sum + r.political_stability, 0) / regions.length,
             averageProsperity: regions.reduce((sum, r) => sum + r.economic_prosperity, 0) / regions.length