burnrate 0.1.0

package/dist/core/pathfinding.d.ts

@@ -0,0 +1,38 @@
+/**
+ * BURNRATE Pathfinding
+ * Find optimal routes between zones
+ */
+import { GameDatabase } from '../db/database.js';
+import { Route } from './types.js';
+/**
+ * Find shortest path between two zones using Dijkstra's algorithm
+ * Optimizes for distance by default, can also factor in risk
+ */
+export declare function findPath(db: GameDatabase, fromZoneId: string, toZoneId: string, options?: {
+    optimizeFor?: 'distance' | 'risk' | 'balanced';
+}): {
+    path: string[];
+    totalDistance: number;
+    totalRisk: number;
+    routes: Route[];
+} | null;
+/**
+ * Find all paths up to a certain length (for showing alternatives)
+ */
+export declare function findAlternativePaths(db: GameDatabase, fromZoneId: string, toZoneId: string, maxPaths?: number): Array<{
+    path: string[];
+    totalDistance: number;
+    totalRisk: number;
+}>;
+/**
+ * Calculate total distance and ETA for a path with a specific shipment type
+ */
+export declare function calculatePathStats(routes: Route[], speedModifier: number): {
+    totalTicks: number;
+    totalDistance: number;
+    legs: Array<{
+        from: string;
+        to: string;
+        ticks: number;
+    }>;
+};

package/dist/core/pathfinding.js

@@ -0,0 +1,146 @@
+/**
+ * BURNRATE Pathfinding
+ * Find optimal routes between zones
+ */
+/**
+ * Find shortest path between two zones using Dijkstra's algorithm
+ * Optimizes for distance by default, can also factor in risk
+ */
+export function findPath(db, fromZoneId, toZoneId, options = {}) {
+    const { optimizeFor = 'distance' } = options;
+    // Get all zones and routes
+    const allZones = db.getAllZones();
+    const zoneIds = new Set(allZones.map(z => z.id));
+    if (!zoneIds.has(fromZoneId) || !zoneIds.has(toZoneId)) {
+        return null;
+    }
+    // Build adjacency map
+    const adjacency = new Map();
+    for (const zone of allZones) {
+        adjacency.set(zone.id, db.getRoutesFromZone(zone.id));
+    }
+    // Dijkstra's algorithm
+    const visited = new Set();
+    const costs = new Map();
+    const paths = new Map();
+    const risks = new Map();
+    const distances = new Map(); // Track actual distances separately
+    const routePaths = new Map();
+    costs.set(fromZoneId, 0);
+    paths.set(fromZoneId, [fromZoneId]);
+    risks.set(fromZoneId, 0);
+    distances.set(fromZoneId, 0);
+    routePaths.set(fromZoneId, []);
+    while (visited.size < zoneIds.size) {
+        // Find unvisited node with lowest cost
+        let current = null;
+        let lowestCost = Infinity;
+        for (const [zoneId, cost] of costs) {
+            if (!visited.has(zoneId) && cost < lowestCost) {
+                lowestCost = cost;
+                current = zoneId;
+            }
+        }
+        if (current === null)
+            break;
+        if (current === toZoneId)
+            break;
+        visited.add(current);
+        // Check all neighbors
+        const routes = adjacency.get(current) || [];
+        for (const route of routes) {
+            const neighbor = route.toZoneId;
+            if (visited.has(neighbor))
+                continue;
+            // Calculate cost based on optimization strategy
+            let edgeCost;
+            switch (optimizeFor) {
+                case 'risk':
+                    edgeCost = route.baseRisk * route.chokepointRating * 100;
+                    break;
+                case 'balanced':
+                    edgeCost = route.distance + route.baseRisk * route.chokepointRating * 50;
+                    break;
+                case 'distance':
+                default:
+                    edgeCost = route.distance;
+            }
+            const newCost = (costs.get(current) || 0) + edgeCost;
+            const currentNeighborCost = costs.get(neighbor) ?? Infinity;
+            if (newCost < currentNeighborCost) {
+                costs.set(neighbor, newCost);
+                paths.set(neighbor, [...(paths.get(current) || []), neighbor]);
+                risks.set(neighbor, (risks.get(current) || 0) + route.baseRisk * route.chokepointRating);
+                distances.set(neighbor, (distances.get(current) || 0) + route.distance);
+                routePaths.set(neighbor, [...(routePaths.get(current) || []), route]);
+            }
+        }
+    }
+    const finalPath = paths.get(toZoneId);
+    if (!finalPath)
+        return null;
+    return {
+        path: finalPath,
+        totalDistance: distances.get(toZoneId) || 0, // Return actual distance, not cost
+        totalRisk: risks.get(toZoneId) || 0,
+        routes: routePaths.get(toZoneId) || []
+    };
+}
+/**
+ * Find all paths up to a certain length (for showing alternatives)
+ */
+export function findAlternativePaths(db, fromZoneId, toZoneId, maxPaths = 3) {
+    const results = [];
+    // Get shortest path
+    const shortest = findPath(db, fromZoneId, toZoneId, { optimizeFor: 'distance' });
+    if (shortest) {
+        results.push({
+            path: shortest.path,
+            totalDistance: shortest.totalDistance,
+            totalRisk: shortest.totalRisk
+        });
+    }
+    // Get safest path
+    const safest = findPath(db, fromZoneId, toZoneId, { optimizeFor: 'risk' });
+    if (safest && !pathsEqual(safest.path, shortest?.path || [])) {
+        results.push({
+            path: safest.path,
+            totalDistance: safest.totalDistance,
+            totalRisk: safest.totalRisk
+        });
+    }
+    // Get balanced path
+    const balanced = findPath(db, fromZoneId, toZoneId, { optimizeFor: 'balanced' });
+    if (balanced && !pathsEqual(balanced.path, shortest?.path || []) && !pathsEqual(balanced.path, safest?.path || [])) {
+        results.push({
+            path: balanced.path,
+            totalDistance: balanced.totalDistance,
+            totalRisk: balanced.totalRisk
+        });
+    }
+    return results.slice(0, maxPaths);
+}
+function pathsEqual(a, b) {
+    if (a.length !== b.length)
+        return false;
+    return a.every((v, i) => v === b[i]);
+}
+/**
+ * Calculate total distance and ETA for a path with a specific shipment type
+ */
+export function calculatePathStats(routes, speedModifier) {
+    let totalTicks = 0;
+    let totalDistance = 0;
+    const legs = [];
+    for (const route of routes) {
+        const ticks = Math.ceil(route.distance * speedModifier);
+        totalTicks += ticks;
+        totalDistance += route.distance;
+        legs.push({
+            from: route.fromZoneId,
+            to: route.toZoneId,
+            ticks
+        });
+    }
+    return { totalTicks, totalDistance, legs };
+}

package/dist/core/types.d.ts

@@ -0,0 +1,489 @@
+/**
+ * BURNRATE Core Types
+ * The front doesn't feed itself.
+ */
+/** T0 Raw Materials */
+export type RawResource = 'ore' | 'fuel' | 'grain' | 'fiber';
+/** T1 Processed Goods */
+export type ProcessedResource = 'metal' | 'chemicals' | 'rations' | 'textiles';
+/** T2 Strategic Goods */
+export type StrategicResource = 'ammo' | 'medkits' | 'parts' | 'comms';
+/** All tradeable resources */
+export type Resource = RawResource | ProcessedResource | StrategicResource;
+/** Resource inventory (including SU) */
+export interface Inventory {
+    ore: number;
+    fuel: number;
+    grain: number;
+    fiber: number;
+    metal: number;
+    chemicals: number;
+    rations: number;
+    textiles: number;
+    ammo: number;
+    medkits: number;
+    parts: number;
+    comms: number;
+    credits: number;
+}
+/** Empty inventory factory */
+export declare function emptyInventory(): Inventory;
+/** SU recipe: what's needed to create 1 Supply Unit */
+export declare const SU_RECIPE: {
+    readonly rations: 2;
+    readonly fuel: 1;
+    readonly parts: 1;
+    readonly ammo: 1;
+};
+/** Production recipes: inputs required to produce 1 unit of output */
+export declare const RECIPES: Record<string, {
+    inputs: Partial<Record<Resource, number>>;
+    tier: number;
+    isUnit?: boolean;
+}>;
+/** What raw resource a Field produces based on its name */
+export declare function getFieldResource(fieldName: string): RawResource | null;
+export type ZoneType = 'hub' | 'factory' | 'field' | 'junction' | 'front' | 'stronghold';
+export interface Zone {
+    id: string;
+    name: string;
+    type: ZoneType;
+    /** Faction that controls this zone (null = neutral) */
+    ownerId: string | null;
+    /** Current supply level (0-100+, percentage of burn rate covered) */
+    supplyLevel: number;
+    /** SU burned per tick to maintain control */
+    burnRate: number;
+    /** Consecutive ticks at 100%+ supply */
+    complianceStreak: number;
+    /** Current SU stockpile */
+    suStockpile: number;
+    /** Zone inventory (for production, markets) */
+    inventory: Inventory;
+    /** Production capacity (units/tick) for factory zones */
+    productionCapacity: number;
+    /** Garrison strength (faction investment) */
+    garrisonLevel: number;
+    /** Market depth multiplier */
+    marketDepth: number;
+    /** Medkit stockpile for combat bonuses */
+    medkitStockpile: number;
+    /** Comms stockpile for intel defense */
+    commsStockpile: number;
+}
+export type SupplyState = 'fortified' | 'supplied' | 'strained' | 'critical' | 'collapsed';
+export declare function getSupplyState(supplyLevel: number, complianceStreak?: number): SupplyState;
+/** Front efficiency: bonuses from supply level and compliance streak */
+export interface ZoneEfficiency {
+    /** Supply state label */
+    state: SupplyState;
+    /** Multiplier for raid resistance (higher = harder to raid) */
+    raidResistance: number;
+    /** Multiplier for capture difficulty (higher = harder to capture) */
+    captureDefense: number;
+    /** Production bonus (0.0 = none, 0.2 = +20%) */
+    productionBonus: number;
+    /** Medkit combat bonus (reduces unit attrition) */
+    medkitBonus: number;
+    /** Comms intel bonus (reduces enemy scan quality) */
+    commsDefense: number;
+}
+/** Calculate zone efficiency from supply state, streak, and stockpiles */
+export declare function getZoneEfficiency(supplyLevel: number, complianceStreak: number, medkitStockpile?: number, commsStockpile?: number): ZoneEfficiency;
+/** Burn rates by zone type */
+export declare const BURN_RATES: Record<ZoneType, number>;
+export interface Route {
+    id: string;
+    fromZoneId: string;
+    toZoneId: string;
+    /** Ticks to traverse */
+    distance: number;
+    /** Max cargo per tick */
+    capacity: number;
+    /** Base interception probability (0-1) */
+    baseRisk: number;
+    /** Chokepoint multiplier for ambushes (1-3) */
+    chokepointRating: number;
+}
+export type ShipmentType = 'courier' | 'freight' | 'convoy';
+export interface Shipment {
+    id: string;
+    playerId: string;
+    type: ShipmentType;
+    /** Route path (zone IDs in order) */
+    path: string[];
+    /** Current position (index in path) */
+    currentPosition: number;
+    /** Ticks remaining until next zone */
+    ticksToNextZone: number;
+    /** Cargo being shipped */
+    cargo: Partial<Inventory>;
+    /** Escort unit IDs attached */
+    escortIds: string[];
+    /** Tick when shipment was created */
+    createdAt: number;
+    /** Status */
+    status: 'in_transit' | 'arrived' | 'intercepted';
+}
+export declare const SHIPMENT_SPECS: Record<ShipmentType, {
+    capacity: number;
+    speedModifier: number;
+    visibilityModifier: number;
+}>;
+/** License unlock requirements */
+export declare const LICENSE_REQUIREMENTS: Record<ShipmentType, {
+    reputationRequired: number;
+    creditsCost: number;
+    description: string;
+}>;
+/** Reputation rewards for various actions */
+export declare const REPUTATION_REWARDS: {
+    readonly shipmentDelivered: 5;
+    readonly shipmentIntercepted: -10;
+    readonly escortSuccess: 3;
+    readonly contractCompleted: 10;
+    readonly contractFailed: -20;
+    readonly contractBonus: 5;
+    readonly supplyDelivered: 2;
+    readonly zoneCaptured: 25;
+    readonly raiderDestroyed: 5;
+    readonly escortDestroyed: -5;
+    readonly tradeCompleted: 1;
+    readonly dailyDecay: -1;
+    readonly maxReputation: 1000;
+};
+/** Reputation thresholds for titles */
+export declare const REPUTATION_TITLES: {
+    threshold: number;
+    title: string;
+}[];
+/** Get reputation title based on rep value */
+export declare function getReputationTitle(reputation: number): string;
+export type UnitType = 'escort' | 'raider';
+export interface Unit {
+    id: string;
+    playerId: string;
+    type: UnitType;
+    /** Current location (zone ID) */
+    locationId: string;
+    /** Combat strength */
+    strength: number;
+    /** Movement speed (affects raider interception range) */
+    speed: number;
+    /** Maintenance cost (credits/tick) */
+    maintenance: number;
+    /** If assigned to a shipment (escort) or route (raider) */
+    assignmentId: string | null;
+    /** If listed for sale, the asking price (null = not for sale) */
+    forSalePrice: number | null;
+}
+export type SubscriptionTier = 'freelance' | 'operator' | 'command';
+export interface Player {
+    id: string;
+    name: string;
+    tier: SubscriptionTier;
+    /** Personal inventory and credits */
+    inventory: Inventory;
+    /** Current location (zone ID) */
+    locationId: string;
+    /** Faction membership */
+    factionId: string | null;
+    /** Global reputation (0-1000) */
+    reputation: number;
+    /** Actions taken today */
+    actionsToday: number;
+    /** Last action timestamp (for rate limiting) */
+    lastActionTick: number;
+    /** Licenses unlocked */
+    licenses: {
+        courier: boolean;
+        freight: boolean;
+        convoy: boolean;
+    };
+    /** Tutorial progress (0-5, each step completed) */
+    tutorialStep: number;
+}
+export declare const TIER_LIMITS: Record<SubscriptionTier, {
+    dailyActions: number;
+    eventHistory: number;
+    concurrentContracts: number;
+    marketOrders: number;
+}>;
+export type FactionRank = 'founder' | 'officer' | 'member';
+/** Permissions for each rank */
+export declare const FACTION_PERMISSIONS: Record<FactionRank, {
+    canInvite: boolean;
+    canKick: boolean;
+    canPromote: boolean;
+    canDemote: boolean;
+    canWithdraw: boolean;
+    canSetDoctrine: boolean;
+    canDeclareWar: boolean;
+    canUpgrade: boolean;
+}>;
+export interface FactionMember {
+    playerId: string;
+    rank: FactionRank;
+    joinedAt: number;
+}
+export interface Faction {
+    id: string;
+    name: string;
+    tag: string;
+    /** Founder player ID */
+    founderId: string;
+    /** Treasury */
+    treasury: Inventory;
+    /** Daily withdrawal limit for officers (credits) */
+    officerWithdrawLimit: number;
+    /** Member list with ranks */
+    members: FactionMember[];
+    /** Zone IDs controlled by this faction */
+    controlledZones: string[];
+    /** Doctrine hash (for compliance tracking) */
+    doctrineHash: string | null;
+    /** Infrastructure upgrades */
+    upgrades: {
+        relayNetwork: number;
+        routeFortification: number;
+        productionBonus: number;
+        garrisonStrength: number;
+        marketDepth: number;
+    };
+    /** Alliance/war state with other factions */
+    relations: Record<string, 'allied' | 'neutral' | 'war'>;
+}
+/** Intel freshness states based on age */
+export type IntelFreshness = 'fresh' | 'stale' | 'expired';
+/** Intel freshness thresholds (in ticks) */
+export declare const INTEL_DECAY_THRESHOLDS: {
+    readonly fresh: 10;
+    readonly stale: 50;
+};
+/** Calculate intel freshness based on age */
+export declare function getIntelFreshness(gatheredAt: number, currentTick: number): IntelFreshness;
+/** Calculate effective signal quality with decay */
+export declare function getDecayedSignalQuality(originalQuality: number, gatheredAt: number, currentTick: number): number;
+/** Apply decay to intel data based on freshness */
+export declare function applyIntelDecay(data: Record<string, unknown>, freshness: IntelFreshness): Record<string, unknown>;
+export interface IntelReport {
+    id: string;
+    playerId: string;
+    /** Faction this intel is shared with (null = private) */
+    factionId: string | null;
+    /** What was scanned */
+    targetType: 'zone' | 'route';
+    targetId: string;
+    /** Tick when gathered */
+    gatheredAt: number;
+    /** Data captured (varies by target type) */
+    data: Record<string, unknown>;
+    /** Signal quality when gathered (0-100) */
+    signalQuality: number;
+}
+/** Intel report with freshness information */
+export interface IntelReportWithFreshness extends IntelReport {
+    freshness: IntelFreshness;
+    effectiveSignalQuality: number;
+    ageInTicks: number;
+}
+export type OrderSide = 'buy' | 'sell';
+export interface MarketOrder {
+    id: string;
+    playerId: string;
+    zoneId: string;
+    resource: Resource;
+    side: OrderSide;
+    /** Price per unit */
+    price: number;
+    /** Quantity remaining */
+    quantity: number;
+    /** Original quantity */
+    originalQuantity: number;
+    /** Tick when placed */
+    createdAt: number;
+}
+export interface Trade {
+    id: string;
+    zoneId: string;
+    resource: Resource;
+    buyerId: string;
+    sellerId: string;
+    price: number;
+    quantity: number;
+    executedAt: number;
+}
+export type ContractType = 'haul' | 'supply' | 'scout' | 'tutorial';
+/** Tutorial contract definitions */
+export declare const TUTORIAL_CONTRACTS: {
+    step: number;
+    title: string;
+    description: string;
+    type: ContractType;
+    reward: {
+        credits: number;
+        reputation: number;
+    };
+}[];
+export interface Contract {
+    id: string;
+    type: ContractType;
+    /** Who posted (player ID or faction ID) */
+    posterId: string;
+    posterType: 'player' | 'faction';
+    /** Who accepted (null if open) */
+    acceptedBy: string | null;
+    /** Contract details (varies by type) */
+    details: {
+        fromZoneId?: string;
+        toZoneId?: string;
+        resource?: Resource;
+        quantity?: number;
+        targetId?: string;
+        targetType?: 'zone' | 'route';
+    };
+    /** Deadline (tick) */
+    deadline: number;
+    /** Reward */
+    reward: {
+        credits: number;
+        reputation: number;
+    };
+    /** Bonus for early completion */
+    bonus?: {
+        deadline: number;
+        credits: number;
+    };
+    status: 'open' | 'active' | 'completed' | 'failed' | 'expired';
+    createdAt: number;
+}
+export type GameEventType = 'tick' | 'shipment_created' | 'shipment_moved' | 'shipment_arrived' | 'shipment_intercepted' | 'trade_executed' | 'order_placed' | 'order_cancelled' | 'zone_supplied' | 'zone_state_changed' | 'zone_captured' | 'combat_resolved' | 'intel_gathered' | 'contract_posted' | 'contract_accepted' | 'contract_completed' | 'contract_failed' | 'faction_created' | 'faction_joined' | 'faction_left' | 'player_action' | 'stockpile_deposited' | 'tutorial_completed' | 'doctrine_updated' | 'webhook_triggered';
+export interface GameEvent {
+    id: string;
+    type: GameEventType;
+    tick: number;
+    timestamp: Date;
+    /** Actor (player/faction) who caused the event */
+    actorId: string | null;
+    actorType: 'player' | 'faction' | 'system';
+    /** Event-specific data */
+    data: Record<string, unknown>;
+}
+/** Season configuration */
+export declare const SEASON_CONFIG: {
+    readonly ticksPerWeek: 1008;
+    readonly weeksPerSeason: 4;
+    readonly ticksPerSeason: 4032;
+    readonly scoring: {
+        readonly zonesControlled: 100;
+        readonly supplyDelivered: 1;
+        readonly shipmentsCompleted: 10;
+        readonly contractsCompleted: 25;
+        readonly reputationGained: 2;
+        readonly combatVictories: 50;
+    };
+};
+/** Season score entry */
+export interface SeasonScore {
+    id: string;
+    seasonNumber: number;
+    entityId: string;
+    entityType: 'player' | 'faction';
+    entityName: string;
+    zonesControlled: number;
+    supplyDelivered: number;
+    shipmentsCompleted: number;
+    contractsCompleted: number;
+    reputationGained: number;
+    combatVictories: number;
+    totalScore: number;
+    rank?: number;
+}
+/** Calculate total score from components */
+export declare function calculateSeasonScore(score: Omit<SeasonScore, 'id' | 'totalScore' | 'rank'>): number;
+export interface WorldState {
+    currentTick: number;
+    seasonNumber: number;
+    seasonWeek: number;
+    zones: Map<string, Zone>;
+    routes: Map<string, Route>;
+    players: Map<string, Player>;
+    factions: Map<string, Faction>;
+    shipments: Map<string, Shipment>;
+    units: Map<string, Unit>;
+    orders: Map<string, MarketOrder>;
+    contracts: Map<string, Contract>;
+    intel: Map<string, IntelReport>;
+}
+export interface Doctrine {
+    id: string;
+    factionId: string;
+    title: string;
+    content: string;
+    version: number;
+    createdAt: number;
+    updatedAt: number;
+    createdBy: string;
+}
+export type WebhookEventType = 'shipment_arrived' | 'shipment_intercepted' | 'zone_critical' | 'zone_collapsed' | 'zone_captured' | 'contract_completed' | 'contract_expired' | 'market_order_filled' | 'under_attack';
+export interface Webhook {
+    id: string;
+    playerId: string;
+    url: string;
+    events: WebhookEventType[];
+    active: boolean;
+    createdAt: number;
+    lastTriggeredAt: number | null;
+    failCount: number;
+}
+export type AdvancedOrderType = 'conditional' | 'time_weighted';
+export interface ConditionalOrder {
+    id: string;
+    playerId: string;
+    zoneId: string;
+    resource: Resource;
+    side: 'buy' | 'sell';
+    triggerPrice: number;
+    quantity: number;
+    condition: 'price_below' | 'price_above';
+    status: 'active' | 'triggered' | 'cancelled';
+    createdAt: number;
+}
+export interface TimeWeightedOrder {
+    id: string;
+    playerId: string;
+    zoneId: string;
+    resource: Resource;
+    side: 'buy' | 'sell';
+    price: number;
+    totalQuantity: number;
+    remainingQuantity: number;
+    quantityPerTick: number;
+    status: 'active' | 'completed' | 'cancelled';
+    createdAt: number;
+}
+export interface GarrisonUpgrade {
+    level: number;
+    defense: number;
+    raidResist: number;
+    maintenance: number;
+}
+export declare const GARRISON_LEVELS: GarrisonUpgrade[];
+export type DiplomacyStatus = 'allied' | 'neutral' | 'war' | 'nap';
+export interface DiplomacyRelation {
+    factionId: string;
+    targetFactionId: string;
+    status: DiplomacyStatus;
+    proposedBy: string;
+    acceptedBy: string | null;
+    createdAt: number;
+}
+export interface AuditLogEntry {
+    id: string;
+    factionId: string;
+    playerId: string;
+    action: string;
+    details: Record<string, unknown>;
+    tick: number;
+    timestamp: Date;
+}