burnrate 0.1.0

package/dist/core/types.js

@@ -0,0 +1,359 @@
+/**
+ * BURNRATE Core Types
+ * The front doesn't feed itself.
+ */
+/** Empty inventory factory */
+export function emptyInventory() {
+    return {
+        ore: 0, fuel: 0, grain: 0, fiber: 0,
+        metal: 0, chemicals: 0, rations: 0, textiles: 0,
+        ammo: 0, medkits: 0, parts: 0, comms: 0,
+        credits: 0
+    };
+}
+/** SU recipe: what's needed to create 1 Supply Unit */
+export const SU_RECIPE = {
+    rations: 2,
+    fuel: 1,
+    parts: 1,
+    ammo: 1
+};
+/** Production recipes: inputs required to produce 1 unit of output */
+export const RECIPES = {
+    // T1 (Processed) - made from T0 (Raw)
+    metal: { inputs: { ore: 2, fuel: 1 }, tier: 1 },
+    chemicals: { inputs: { ore: 1, fuel: 2 }, tier: 1 },
+    rations: { inputs: { grain: 3, fuel: 1 }, tier: 1 },
+    textiles: { inputs: { fiber: 2, chemicals: 1 }, tier: 1 },
+    // T2 (Strategic) - made from T1 (Processed)
+    ammo: { inputs: { metal: 1, chemicals: 1 }, tier: 2 },
+    medkits: { inputs: { chemicals: 1, textiles: 1 }, tier: 2 },
+    parts: { inputs: { metal: 1, textiles: 1 }, tier: 2 },
+    comms: { inputs: { metal: 1, chemicals: 1, parts: 1 }, tier: 2 },
+    // T3 (Military Units) - made from T2 (Strategic)
+    escort: { inputs: { metal: 2, parts: 1, rations: 1 }, tier: 3, isUnit: true },
+    raider: { inputs: { metal: 2, parts: 2, comms: 1 }, tier: 3, isUnit: true },
+};
+/** What raw resource a Field produces based on its name */
+export function getFieldResource(fieldName) {
+    if (fieldName.includes('Ore'))
+        return 'ore';
+    if (fieldName.includes('Fuel'))
+        return 'fuel';
+    if (fieldName.includes('Grain'))
+        return 'grain';
+    if (fieldName.includes('Fiber'))
+        return 'fiber';
+    return null;
+}
+export function getSupplyState(supplyLevel, complianceStreak = 0) {
+    if (supplyLevel >= 100 && complianceStreak >= 50)
+        return 'fortified';
+    if (supplyLevel >= 100)
+        return 'supplied';
+    if (supplyLevel >= 50)
+        return 'strained';
+    if (supplyLevel > 0)
+        return 'critical';
+    return 'collapsed';
+}
+/** Calculate zone efficiency from supply state, streak, and stockpiles */
+export function getZoneEfficiency(supplyLevel, complianceStreak, medkitStockpile = 0, commsStockpile = 0) {
+    const state = getSupplyState(supplyLevel, complianceStreak);
+    // Base values by supply state
+    let raidResistance = 1.0;
+    let captureDefense = 1.0;
+    let productionBonus = 0.0;
+    switch (state) {
+        case 'fortified':
+            raidResistance = 1.5;
+            captureDefense = 1.5;
+            productionBonus = 0.1;
+            break;
+        case 'supplied':
+            raidResistance = 1.0;
+            captureDefense = 1.0;
+            productionBonus = 0.0;
+            break;
+        case 'strained':
+            raidResistance = 0.75;
+            captureDefense = 0.75;
+            productionBonus = 0.0;
+            break;
+        case 'critical':
+            raidResistance = 0.5;
+            captureDefense = 0.25;
+            productionBonus = 0.0;
+            break;
+        case 'collapsed':
+            raidResistance = 0.0;
+            captureDefense = 0.0;
+            productionBonus = 0.0;
+            break;
+    }
+    // Compliance streak bonuses (stacking on top of fortified)
+    if (complianceStreak >= 500) {
+        raidResistance += 0.5;
+        captureDefense += 0.5;
+        productionBonus += 0.2;
+    }
+    else if (complianceStreak >= 200) {
+        raidResistance += 0.25;
+        captureDefense += 0.25;
+        productionBonus += 0.1;
+    }
+    else if (complianceStreak >= 50) {
+        raidResistance += 0.1;
+        captureDefense += 0.1;
+    }
+    // Medkit stockpile → combat bonus (diminishing returns, cap at +50%)
+    const medkitBonus = Math.min(0.5, medkitStockpile * 0.02);
+    // Comms stockpile → intel defense (diminishing returns, cap at +50%)
+    const commsDefense = Math.min(0.5, commsStockpile * 0.025);
+    return { state, raidResistance, captureDefense, productionBonus, medkitBonus, commsDefense };
+}
+/** Burn rates by zone type */
+export const BURN_RATES = {
+    hub: 0, // Hubs don't burn (safe zones)
+    factory: 5,
+    field: 3,
+    junction: 0, // Junctions don't burn (transit only)
+    front: 10,
+    stronghold: 20
+};
+export const SHIPMENT_SPECS = {
+    courier: { capacity: 10, speedModifier: 0.67, visibilityModifier: 0.5 },
+    freight: { capacity: 50, speedModifier: 1.0, visibilityModifier: 1.0 },
+    convoy: { capacity: 200, speedModifier: 1.33, visibilityModifier: 2.0 }
+};
+/** License unlock requirements */
+export const LICENSE_REQUIREMENTS = {
+    courier: { reputationRequired: 0, creditsCost: 0, description: 'Basic small cargo transport' },
+    freight: { reputationRequired: 50, creditsCost: 500, description: 'Medium cargo transport' },
+    convoy: { reputationRequired: 200, creditsCost: 2000, description: 'Heavy armored transport' }
+};
+/** Reputation rewards for various actions */
+export const REPUTATION_REWARDS = {
+    // Shipments
+    shipmentDelivered: 5, // per successful delivery
+    shipmentIntercepted: -10, // lost cargo
+    escortSuccess: 3, // escort protected a shipment
+    // Contracts
+    contractCompleted: 10, // base reward (+ contract-specific)
+    contractFailed: -20, // failed to complete
+    contractBonus: 5, // completed early
+    // Zone supply
+    supplyDelivered: 2, // per SU delivered
+    zoneCaptured: 25, // captured a zone
+    // Combat
+    raiderDestroyed: 5, // destroyed an enemy raider
+    escortDestroyed: -5, // lost an escort
+    // Market
+    tradeCompleted: 1, // completed a trade
+    // Daily decay (for inactive players)
+    dailyDecay: -1, // lose 1 rep per day of inactivity
+    // Maximum reputation
+    maxReputation: 1000
+};
+/** Reputation thresholds for titles */
+export const REPUTATION_TITLES = [
+    { threshold: 0, title: 'Unknown' },
+    { threshold: 25, title: 'Runner' },
+    { threshold: 50, title: 'Trader' },
+    { threshold: 100, title: 'Hauler' },
+    { threshold: 200, title: 'Merchant' },
+    { threshold: 350, title: 'Supplier' },
+    { threshold: 500, title: 'Quartermaster' },
+    { threshold: 700, title: 'Logistics Chief' },
+    { threshold: 900, title: 'Supply Marshal' },
+    { threshold: 1000, title: 'Legend' }
+];
+/** Get reputation title based on rep value */
+export function getReputationTitle(reputation) {
+    for (let i = REPUTATION_TITLES.length - 1; i >= 0; i--) {
+        if (reputation >= REPUTATION_TITLES[i].threshold) {
+            return REPUTATION_TITLES[i].title;
+        }
+    }
+    return 'Unknown';
+}
+export const TIER_LIMITS = {
+    freelance: { dailyActions: 200, eventHistory: 200, concurrentContracts: 3, marketOrders: 5 },
+    operator: { dailyActions: 500, eventHistory: 10000, concurrentContracts: 10, marketOrders: 20 },
+    command: { dailyActions: 1000, eventHistory: 100000, concurrentContracts: 25, marketOrders: 50 }
+};
+/** Permissions for each rank */
+export const FACTION_PERMISSIONS = {
+    founder: {
+        canInvite: true,
+        canKick: true,
+        canPromote: true,
+        canDemote: true,
+        canWithdraw: true,
+        canSetDoctrine: true,
+        canDeclareWar: true,
+        canUpgrade: true
+    },
+    officer: {
+        canInvite: true,
+        canKick: true, // can kick members only, not officers
+        canPromote: false,
+        canDemote: false,
+        canWithdraw: true, // up to officer limit
+        canSetDoctrine: false,
+        canDeclareWar: false,
+        canUpgrade: false
+    },
+    member: {
+        canInvite: false,
+        canKick: false,
+        canPromote: false,
+        canDemote: false,
+        canWithdraw: false,
+        canSetDoctrine: false,
+        canDeclareWar: false,
+        canUpgrade: false
+    }
+};
+/** Intel freshness thresholds (in ticks) */
+export const INTEL_DECAY_THRESHOLDS = {
+    fresh: 10, // <10 ticks: full accuracy
+    stale: 50, // 10-50 ticks: degraded accuracy
+    // >50 ticks: expired, major degradation
+};
+/** Calculate intel freshness based on age */
+export function getIntelFreshness(gatheredAt, currentTick) {
+    const age = currentTick - gatheredAt;
+    if (age < INTEL_DECAY_THRESHOLDS.fresh)
+        return 'fresh';
+    if (age < INTEL_DECAY_THRESHOLDS.stale)
+        return 'stale';
+    return 'expired';
+}
+/** Calculate effective signal quality with decay */
+export function getDecayedSignalQuality(originalQuality, gatheredAt, currentTick) {
+    const freshness = getIntelFreshness(gatheredAt, currentTick);
+    switch (freshness) {
+        case 'fresh':
+            return originalQuality;
+        case 'stale':
+            // Lose 1% per tick after fresh threshold
+            const staleAge = currentTick - gatheredAt - INTEL_DECAY_THRESHOLDS.fresh;
+            return Math.max(50, originalQuality - staleAge);
+        case 'expired':
+            // Minimum 20% quality for expired intel
+            return Math.max(20, originalQuality * 0.3);
+    }
+}
+/** Apply decay to intel data based on freshness */
+export function applyIntelDecay(data, freshness) {
+    if (freshness === 'fresh') {
+        return { ...data };
+    }
+    const decayed = { ...data };
+    if (freshness === 'stale') {
+        // For stale intel, add uncertainty to numeric values
+        for (const [key, value] of Object.entries(decayed)) {
+            if (typeof value === 'number' && key !== 'distance') {
+                // Add ±10% noise to numbers
+                const variance = Math.round(value * 0.1);
+                decayed[key] = value + (Math.random() > 0.5 ? variance : -variance);
+            }
+        }
+        decayed._stale = true;
+        decayed._warning = 'Intel is stale. Values may be inaccurate.';
+    }
+    if (freshness === 'expired') {
+        // For expired intel, heavily degrade or remove sensitive data
+        const sensitiveKeys = ['raiderStrength', 'raiderPresence', 'activeShipments',
+            'suStockpile', 'supplyLevel', 'marketActivity'];
+        for (const key of sensitiveKeys) {
+            if (key in decayed) {
+                if (typeof decayed[key] === 'number') {
+                    // Replace with "unknown" range
+                    const originalValue = decayed[key];
+                    decayed[key] = `~${Math.round(originalValue * 0.5)}-${Math.round(originalValue * 1.5)}`;
+                }
+                else if (typeof decayed[key] === 'boolean') {
+                    decayed[key] = 'unknown';
+                }
+            }
+        }
+        decayed._expired = true;
+        decayed._warning = 'Intel is expired. Data is unreliable and should be refreshed.';
+    }
+    return decayed;
+}
+/** Tutorial contract definitions */
+export const TUTORIAL_CONTRACTS = [
+    {
+        step: 1,
+        title: 'First Haul',
+        description: 'Buy 20 ore at the Hub market and deliver it to an adjacent Factory. This teaches market buying, inventory management, and basic shipping.',
+        type: 'tutorial',
+        reward: { credits: 100, reputation: 5 }
+    },
+    {
+        step: 2,
+        title: 'Factory Floor',
+        description: 'At a Factory, produce 10 metal from ore. This teaches production recipes and resource conversion.',
+        type: 'tutorial',
+        reward: { credits: 150, reputation: 5 }
+    },
+    {
+        step: 3,
+        title: 'Supply Run',
+        description: 'Craft and deposit 5 Supply Units to any Front zone. This teaches the SU recipe, supply mechanics, and multi-hop route planning.',
+        type: 'tutorial',
+        reward: { credits: 250, reputation: 10 }
+    },
+    {
+        step: 4,
+        title: 'Intel Sweep',
+        description: 'Scan 3 different zones to gather intel. This teaches the intel system, freshness decay, and faction intel sharing.',
+        type: 'tutorial',
+        reward: { credits: 200, reputation: 5 }
+    },
+    {
+        step: 5,
+        title: 'Join the Fight',
+        description: 'Join a faction and deposit any resource to the faction treasury. This teaches faction membership, treasury mechanics, and collaborative play.',
+        type: 'tutorial',
+        reward: { credits: 500, reputation: 15 }
+    }
+];
+// ============================================================================
+// SEASONS
+// ============================================================================
+/** Season configuration */
+export const SEASON_CONFIG = {
+    ticksPerWeek: 1008, // 7 days * 144 ticks/day
+    weeksPerSeason: 4, // 4 weeks per season
+    ticksPerSeason: 4032, // 4 weeks * 1008 ticks
+    // Scoring weights
+    scoring: {
+        zonesControlled: 100, // per zone at season end
+        supplyDelivered: 1, // per SU delivered
+        shipmentsCompleted: 10, // per successful delivery
+        contractsCompleted: 25, // per contract completed
+        reputationGained: 2, // per reputation point gained
+        combatVictories: 50, // per successful defense/raid
+    }
+};
+/** Calculate total score from components */
+export function calculateSeasonScore(score) {
+    return (score.zonesControlled * SEASON_CONFIG.scoring.zonesControlled +
+        score.supplyDelivered * SEASON_CONFIG.scoring.supplyDelivered +
+        score.shipmentsCompleted * SEASON_CONFIG.scoring.shipmentsCompleted +
+        score.contractsCompleted * SEASON_CONFIG.scoring.contractsCompleted +
+        score.reputationGained * SEASON_CONFIG.scoring.reputationGained +
+        score.combatVictories * SEASON_CONFIG.scoring.combatVictories);
+}
+export const GARRISON_LEVELS = [
+    { level: 0, defense: 0, raidResist: 0, maintenance: 0 },
+    { level: 1, defense: 0.1, raidResist: 0.1, maintenance: 10 },
+    { level: 2, defense: 0.2, raidResist: 0.2, maintenance: 25 },
+    { level: 3, defense: 0.35, raidResist: 0.35, maintenance: 50 },
+    { level: 4, defense: 0.5, raidResist: 0.5, maintenance: 100 },
+    { level: 5, defense: 0.75, raidResist: 0.75, maintenance: 200 },
+];

package/dist/core/worldgen.d.ts

@@ -0,0 +1,22 @@
+/**
+ * BURNRATE World Generator
+ * Creates the initial map for a new season
+ */
+import { GameDatabase } from '../db/database.js';
+interface WorldGenConfig {
+    hubs: number;
+    factories: number;
+    fields: number;
+    junctions: number;
+    fronts: number;
+    strongholds: number;
+}
+/**
+ * Generate a new world for Season 1
+ */
+export declare function generateWorld(db: GameDatabase, config?: WorldGenConfig): void;
+/**
+ * Seed initial market prices in zones
+ */
+export declare function seedMarkets(db: GameDatabase): void;
+export {};

package/dist/core/worldgen.js

@@ -0,0 +1,292 @@
+/**
+ * BURNRATE World Generator
+ * Creates the initial map for a new season
+ */
+import { BURN_RATES, emptyInventory } from './types.js';
+const DEFAULT_CONFIG = {
+    hubs: 3,
+    factories: 8,
+    fields: 12,
+    junctions: 10,
+    fronts: 6,
+    strongholds: 3
+};
+/**
+ * Generate a new world for Season 1
+ */
+export function generateWorld(db, config = DEFAULT_CONFIG) {
+    const zones = [];
+    // Generate Hubs (safe starting areas)
+    const hubNames = ['Hub.Central', 'Hub.East', 'Hub.West'];
+    for (let i = 0; i < config.hubs; i++) {
+        const zone = db.createZone({
+            name: hubNames[i] || `Hub.${i + 1}`,
+            type: 'hub',
+            ownerId: null,
+            supplyLevel: 100,
+            burnRate: BURN_RATES.hub,
+            complianceStreak: 0,
+            suStockpile: 0,
+            inventory: { ...emptyInventory(), credits: 10000 }, // Hub has market liquidity
+            productionCapacity: 0,
+            garrisonLevel: 10, // Hubs are well defended
+            marketDepth: 2.0,
+            medkitStockpile: 0,
+            commsStockpile: 0
+        });
+        zones.push(zone);
+    }
+    // Generate Factories
+    const factoryNames = [
+        'Factory.North', 'Factory.South', 'Factory.Iron', 'Factory.Chemical',
+        'Factory.Munitions', 'Factory.Textile', 'Factory.Parts', 'Factory.Comms'
+    ];
+    for (let i = 0; i < config.factories; i++) {
+        const zone = db.createZone({
+            name: factoryNames[i] || `Factory.${i + 1}`,
+            type: 'factory',
+            ownerId: null,
+            supplyLevel: 100,
+            burnRate: BURN_RATES.factory,
+            complianceStreak: 0,
+            suStockpile: 50,
+            inventory: emptyInventory(),
+            productionCapacity: 100, // Can produce 100 units/tick
+            garrisonLevel: 2,
+            marketDepth: 1.0,
+            medkitStockpile: 0,
+            commsStockpile: 0
+        });
+        zones.push(zone);
+    }
+    // Generate Fields (resource extraction)
+    const fieldNames = [
+        'Field.Ore.Alpha', 'Field.Ore.Beta', 'Field.Ore.Gamma',
+        'Field.Fuel.1', 'Field.Fuel.2', 'Field.Fuel.3',
+        'Field.Grain.North', 'Field.Grain.South', 'Field.Grain.Valley',
+        'Field.Fiber.1', 'Field.Fiber.2', 'Field.Fiber.3'
+    ];
+    for (let i = 0; i < config.fields; i++) {
+        // Determine what this field produces based on name
+        const name = fieldNames[i] || `Field.${i + 1}`;
+        let inventory = emptyInventory();
+        if (name.includes('Ore'))
+            inventory.ore = 500;
+        else if (name.includes('Fuel'))
+            inventory.fuel = 500;
+        else if (name.includes('Grain'))
+            inventory.grain = 500;
+        else if (name.includes('Fiber'))
+            inventory.fiber = 500;
+        const zone = db.createZone({
+            name,
+            type: 'field',
+            ownerId: null,
+            supplyLevel: 100,
+            burnRate: BURN_RATES.field,
+            complianceStreak: 0,
+            suStockpile: 30,
+            inventory,
+            productionCapacity: 50, // Extraction rate
+            garrisonLevel: 1,
+            marketDepth: 0.5,
+            medkitStockpile: 0,
+            commsStockpile: 0
+        });
+        zones.push(zone);
+    }
+    // Generate Junctions (crossroads)
+    const junctionNames = [
+        'Junction.1', 'Junction.2', 'Junction.3', 'Junction.4', 'Junction.5',
+        'Junction.North', 'Junction.South', 'Junction.East', 'Junction.West', 'Junction.Center'
+    ];
+    for (let i = 0; i < config.junctions; i++) {
+        const zone = db.createZone({
+            name: junctionNames[i] || `Junction.${i + 1}`,
+            type: 'junction',
+            ownerId: null,
+            supplyLevel: 100,
+            burnRate: BURN_RATES.junction,
+            complianceStreak: 0,
+            suStockpile: 0,
+            inventory: emptyInventory(),
+            productionCapacity: 0,
+            garrisonLevel: 0,
+            marketDepth: 0.3,
+            medkitStockpile: 0,
+            commsStockpile: 0
+        });
+        zones.push(zone);
+    }
+    // Generate Fronts (contested zones)
+    const frontNames = [
+        'Front.Kessel', 'Front.Ardenne', 'Front.Kursk',
+        'Front.Marne', 'Front.Somme', 'Front.Verdun'
+    ];
+    for (let i = 0; i < config.fronts; i++) {
+        const zone = db.createZone({
+            name: frontNames[i] || `Front.${i + 1}`,
+            type: 'front',
+            ownerId: null,
+            supplyLevel: 0, // Starts unsupplied
+            burnRate: BURN_RATES.front,
+            complianceStreak: 0,
+            suStockpile: 0,
+            inventory: emptyInventory(),
+            productionCapacity: 0,
+            garrisonLevel: 0,
+            marketDepth: 0.2,
+            medkitStockpile: 0,
+            commsStockpile: 0
+        });
+        zones.push(zone);
+    }
+    // Generate Strongholds (victory points)
+    const strongholdNames = ['Stronghold.Prime', 'Stronghold.Alpha', 'Stronghold.Omega'];
+    for (let i = 0; i < config.strongholds; i++) {
+        const zone = db.createZone({
+            name: strongholdNames[i] || `Stronghold.${i + 1}`,
+            type: 'stronghold',
+            ownerId: null,
+            supplyLevel: 0,
+            burnRate: BURN_RATES.stronghold,
+            complianceStreak: 0,
+            suStockpile: 0,
+            inventory: emptyInventory(),
+            productionCapacity: 0,
+            garrisonLevel: 5,
+            marketDepth: 0.1,
+            medkitStockpile: 0,
+            commsStockpile: 0
+        });
+        zones.push(zone);
+    }
+    // Generate Routes
+    // Strategy: Create a connected graph with logical geography
+    const zoneMap = new Map(zones.map(z => [z.name, z]));
+    // Helper to create bidirectional routes
+    const connectZones = (from, to, distance, risk, chokepoint = 1.0) => {
+        const fromZone = zoneMap.get(from);
+        const toZone = zoneMap.get(to);
+        if (!fromZone || !toZone)
+            return;
+        // Create route in both directions
+        db.createRoute({
+            fromZoneId: fromZone.id,
+            toZoneId: toZone.id,
+            distance,
+            capacity: 500,
+            baseRisk: risk,
+            chokepointRating: chokepoint
+        });
+        db.createRoute({
+            fromZoneId: toZone.id,
+            toZoneId: fromZone.id,
+            distance,
+            capacity: 500,
+            baseRisk: risk,
+            chokepointRating: chokepoint
+        });
+    };
+    // Hub connections (safe routes between hubs)
+    connectZones('Hub.Central', 'Hub.East', 2, 0.02);
+    connectZones('Hub.Central', 'Hub.West', 2, 0.02);
+    connectZones('Hub.East', 'Hub.West', 3, 0.03);
+    // Hub to Factory routes
+    connectZones('Hub.Central', 'Factory.North', 2, 0.05);
+    connectZones('Hub.Central', 'Factory.South', 2, 0.05);
+    connectZones('Hub.East', 'Factory.Iron', 2, 0.05);
+    connectZones('Hub.East', 'Factory.Chemical', 2, 0.05);
+    connectZones('Hub.West', 'Factory.Munitions', 2, 0.05);
+    connectZones('Hub.West', 'Factory.Textile', 2, 0.05);
+    // Factory to Field routes
+    connectZones('Factory.Iron', 'Field.Ore.Alpha', 3, 0.08);
+    connectZones('Factory.Iron', 'Field.Ore.Beta', 3, 0.08);
+    connectZones('Factory.Chemical', 'Field.Fuel.1', 3, 0.08);
+    connectZones('Factory.Chemical', 'Field.Fuel.2', 3, 0.08);
+    connectZones('Factory.Textile', 'Field.Fiber.1', 3, 0.08);
+    connectZones('Factory.Textile', 'Field.Grain.North', 3, 0.08);
+    connectZones('Factory.North', 'Field.Ore.Gamma', 2, 0.06);
+    connectZones('Factory.South', 'Field.Fuel.3', 2, 0.06);
+    // Factory interconnections
+    connectZones('Factory.North', 'Factory.Iron', 2, 0.06);
+    connectZones('Factory.South', 'Factory.Chemical', 2, 0.06);
+    connectZones('Factory.Parts', 'Factory.Iron', 2, 0.06);
+    connectZones('Factory.Parts', 'Factory.Textile', 2, 0.06);
+    connectZones('Factory.Comms', 'Factory.Parts', 2, 0.06);
+    connectZones('Factory.Munitions', 'Factory.Chemical', 2, 0.06);
+    // Junction connections (crossroads)
+    connectZones('Junction.1', 'Factory.North', 2, 0.10);
+    connectZones('Junction.1', 'Factory.Parts', 2, 0.10);
+    connectZones('Junction.2', 'Factory.South', 2, 0.10);
+    connectZones('Junction.2', 'Factory.Munitions', 2, 0.10);
+    connectZones('Junction.3', 'Factory.Iron', 2, 0.10);
+    connectZones('Junction.4', 'Factory.Chemical', 2, 0.10);
+    connectZones('Junction.5', 'Factory.Textile', 2, 0.10);
+    // Junction to Junction (main arteries)
+    connectZones('Junction.1', 'Junction.North', 2, 0.12);
+    connectZones('Junction.2', 'Junction.South', 2, 0.12);
+    connectZones('Junction.3', 'Junction.East', 2, 0.12);
+    connectZones('Junction.4', 'Junction.West', 2, 0.12);
+    connectZones('Junction.5', 'Junction.Center', 2, 0.12);
+    connectZones('Junction.North', 'Junction.Center', 2, 0.15);
+    connectZones('Junction.South', 'Junction.Center', 2, 0.15);
+    connectZones('Junction.East', 'Junction.Center', 2, 0.15);
+    connectZones('Junction.West', 'Junction.Center', 2, 0.15);
+    // Front connections (dangerous routes)
+    connectZones('Junction.North', 'Front.Kessel', 3, 0.25, 1.5);
+    connectZones('Junction.East', 'Front.Ardenne', 3, 0.25, 1.5);
+    connectZones('Junction.South', 'Front.Kursk', 3, 0.25, 1.5);
+    connectZones('Junction.West', 'Front.Marne', 3, 0.25, 1.5);
+    connectZones('Junction.Center', 'Front.Somme', 3, 0.30, 2.0); // Major chokepoint
+    connectZones('Junction.Center', 'Front.Verdun', 3, 0.30, 2.0);
+    // Front interconnections
+    connectZones('Front.Kessel', 'Front.Ardenne', 4, 0.35, 1.8);
+    connectZones('Front.Ardenne', 'Front.Kursk', 4, 0.35, 1.8);
+    connectZones('Front.Kursk', 'Front.Marne', 4, 0.35, 1.8);
+    connectZones('Front.Marne', 'Front.Somme', 3, 0.30, 1.5);
+    connectZones('Front.Somme', 'Front.Verdun', 3, 0.30, 1.5);
+    connectZones('Front.Verdun', 'Front.Kessel', 4, 0.35, 1.8);
+    // Stronghold connections (hardest routes)
+    connectZones('Front.Kessel', 'Stronghold.Prime', 5, 0.40, 2.5);
+    connectZones('Front.Somme', 'Stronghold.Prime', 5, 0.40, 2.5);
+    connectZones('Front.Ardenne', 'Stronghold.Alpha', 5, 0.40, 2.5);
+    connectZones('Front.Kursk', 'Stronghold.Alpha', 5, 0.40, 2.5);
+    connectZones('Front.Marne', 'Stronghold.Omega', 5, 0.40, 2.5);
+    connectZones('Front.Verdun', 'Stronghold.Omega', 5, 0.40, 2.5);
+    // Some alternative routes (bypass options)
+    connectZones('Hub.Central', 'Junction.Center', 4, 0.15); // Direct but longer
+    connectZones('Hub.East', 'Junction.East', 3, 0.12);
+    connectZones('Hub.West', 'Junction.West', 3, 0.12);
+    // Field interconnections
+    connectZones('Field.Ore.Alpha', 'Field.Ore.Beta', 2, 0.08);
+    connectZones('Field.Fuel.1', 'Field.Fuel.2', 2, 0.08);
+    connectZones('Field.Grain.North', 'Field.Grain.South', 2, 0.08);
+    connectZones('Field.Fiber.1', 'Field.Fiber.2', 2, 0.08);
+    console.log(`Generated world with ${zones.length} zones`);
+}
+/**
+ * Seed initial market prices in zones
+ */
+export function seedMarkets(db) {
+    const zones = db.getAllZones();
+    for (const zone of zones) {
+        if (zone.type === 'hub') {
+            // Add some initial inventory for trading
+            const inventory = { ...zone.inventory };
+            inventory.ore = 200;
+            inventory.fuel = 200;
+            inventory.grain = 200;
+            inventory.fiber = 200;
+            inventory.metal = 100;
+            inventory.chemicals = 100;
+            inventory.rations = 100;
+            inventory.textiles = 100;
+            inventory.ammo = 50;
+            inventory.medkits = 50;
+            inventory.parts = 50;
+            inventory.comms = 25;
+            db.updateZone(zone.id, { inventory });
+        }
+    }
+}