diff --git a/CLAUDE.md b/CLAUDE.md index 37a6150..870113b 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -9,7 +9,7 @@ La specifica vincolante è `docs/GUIDA.md`; lo stato dei lavori è in `docs/STAT scripts/build.sh # check-nuget + build Release della soluzione scripts/test.sh [filtri] # build + validate-data + tutti i test (--skip-slow, --serial) dotnet run --project tests/RailEnterprise.Tests -- --list -dotnet run --project src/RailEnterprise.Tools -- # validate-data, genmap, profile, simulate, bench, replay +dotnet run --project src/RailEnterprise.Tools -- # validate-data, genmap, profile, simulate, balance, bench, replay ``` ## Regole non negoziabili diff --git a/data/ai.json b/data/ai.json index 3cb9d40..f087d78 100644 --- a/data/ai.json +++ b/data/ai.json @@ -36,11 +36,12 @@ "commuterCoverage": 0.6, "hubShare": 0.25, "noPartsFactor": 0.5, - "townBonus": 1.8, - "townRoiFactor": 0.5, + "townBonus": 3.0, + "townRoiFactor": 0.35, "repayCashMonths": 12, "planningDaySpacing": 7, - "failedMemory": 64 + "failedMemory": 64, + "partsDeferYears": 3.0 }, "market": { "founderAcceptPremium": 0.4, @@ -63,11 +64,25 @@ "cashReserveMultiple": 2.0, "maxTrainsPerMonth": 1 }, + "trading": { + "enabled": true, + "minMargin": 0.25, + "priceSlack": 0.06, + "minSellPriceShare": 0.9, + "maxUnits": 150, + "maxTradesPerMonth": 2, + "cashShare": 0.15, + "cashReserveMultiple": 2.0 + }, "personalities": [ { "id": "expansive", "name_it": "Espansiva", "roiThreshold": 0.08, "loanShareOfCredit": 0.8, "targetsPlayer": false, "buysShares": false, "maintenancePolicy": "standard" }, { "id": "prudent", "name_it": "Prudente", "roiThreshold": 0.15, "loanShareOfCredit": 0.3, "targetsPlayer": false, "buysShares": false, "maintenancePolicy": "standard" }, { "id": "predatory", "name_it": "Predatoria", "roiThreshold": 0.10, "loanShareOfCredit": 0.6, "targetsPlayer": true, "buysShares": true, "maintenancePolicy": "standard" } ], + "bots": [ + { "id": "bot_competent", "name_it": "Bot competente", "roiThreshold": 0.10, "loanShareOfCredit": 0.6, "targetsPlayer": false, "buysShares": false, "maintenancePolicy": "standard" }, + { "id": "bot_prudent", "name_it": "Bot prudente", "roiThreshold": 0.18, "loanShareOfCredit": 0.25, "targetsPlayer": false, "buysShares": false, "maintenancePolicy": "thorough" } + ], "companyNames": [ "Strade Ferrate del Nord", "Società Ferroviaria Adriatica", "Compagnia delle Valli", "Ferrovie Meridionali", "Società Anonima delle Strade Ferrate", "Ferrovia Alta Valle", "Compagnia Lombardo-Veneta", "Rete del Litorale" diff --git a/data/balance.json b/data/balance.json index 31cdfea..c4f24ce 100644 --- a/data/balance.json +++ b/data/balance.json @@ -47,7 +47,7 @@ "maxPriceFactor": 3.0, "ratioMin": 0.2, "ratioMax": 5.0, - "world": { "amplitude": 0.12, "periodYears": 6, "volumeShare": 0.5, "baselinePerDay": 4.0, "elasticity": 1.0, + "world": { "amplitude": 0.12, "periodYears": 6, "volumeShare": 1.0, "baselinePerDay": 4.0, "elasticity": 2.5, "shockChancePerYear": 0.25, "shockMin": 0.08, "shockMax": 0.30, "shockDecayDays": 150, "priceFloor": 0.05 }, "historyDays": 720, "outlook": { "historyMonths": 24, "changeDays": 30, "forecastMonths": 4, "forecastBandPerMonth": 0.03, "sellPlaces": 3, "eventThreshold": 0.05 } diff --git a/data/schema/ai.schema.json b/data/schema/ai.schema.json index 9888e27..c68545b 100644 --- a/data/schema/ai.schema.json +++ b/data/schema/ai.schema.json @@ -12,16 +12,225 @@ }, "planning": { "type": "object", - "additionalProperties": { - "type": [ - "number", - "integer", - "boolean", - "array", - "object", - "string" - ] - } + "properties": { + "intervalDays": { + "type": "integer", + "minimum": 1 + }, + "maxCandidates": { + "type": "integer", + "minimum": 1 + }, + "maxProjectsPerMonth": { + "type": "integer", + "minimum": 1 + }, + "candidateMaxDistanceKm": { + "type": "number", + "exclusiveMinimum": 0 + }, + "candidateMinDistanceKm": { + "type": "number", + "minimum": 0 + }, + "pathSlopePenalty": { + "type": "number", + "minimum": 0 + }, + "pathWaterPenalty": { + "type": "number", + "minimum": 0 + }, + "steepPenalty": { + "type": "number", + "minimum": 0 + }, + "steepGradeFactor": { + "type": "number", + "exclusiveMinimum": 0 + }, + "pathMarginRetryKm": { + "type": "number", + "minimum": 0 + }, + "trainsPerLine": { + "type": "integer", + "minimum": 1 + }, + "wagonsPerTrain": { + "type": "integer", + "minimum": 1 + }, + "cashReserveMonths": { + "type": "number", + "minimum": 0 + }, + "revenueHorizonYears": { + "type": "number", + "exclusiveMinimum": 0 + }, + "maxRejectedShare": { + "type": "number", + "minimum": 0, + "maximum": 1 + }, + "maxConcurrentProjects": { + "type": "integer", + "minimum": 1 + }, + "evaluateTop": { + "type": "integer", + "minimum": 1 + }, + "pathMarginKm": { + "type": "number", + "minimum": 0 + }, + "simplifyToleranceM": { + "type": "number", + "minimum": 0 + }, + "stationOffsetsM": { + "type": "array", + "minItems": 1, + "items": { + "type": "number", + "minimum": 0 + } + }, + "depotOffsetM": { + "type": "number", + "minimum": 0 + }, + "platforms": { + "type": "integer", + "minimum": 1 + }, + "hubPlatforms": { + "type": "integer", + "minimum": 1 + }, + "assumedEfficiency": { + "type": "number", + "exclusiveMinimum": 0, + "maximum": 1 + }, + "speedFactor": { + "type": "number", + "exclusiveMinimum": 0, + "maximum": 1 + }, + "dwellMinutes": { + "type": "number", + "minimum": 0 + }, + "maintenanceCostShare": { + "type": "number", + "minimum": 0, + "maximum": 1 + }, + "trackUpkeepPerKmPerYear": { + "type": "integer", + "minimum": 0 + }, + "maxTrainsPerLine": { + "type": "integer", + "minimum": 1 + }, + "addTrainWaitingTrips": { + "type": "number", + "minimum": 0 + }, + "minCommuters": { + "type": "integer", + "minimum": 0 + }, + "commuterCoverage": { + "type": "number", + "minimum": 0, + "maximum": 1 + }, + "hubShare": { + "type": "number", + "minimum": 0, + "maximum": 1 + }, + "noPartsFactor": { + "type": "number", + "minimum": 0, + "maximum": 1 + }, + "townBonus": { + "type": "number", + "minimum": 1, + "maximum": 10 + }, + "townRoiFactor": { + "type": "number", + "exclusiveMinimum": 0, + "maximum": 1 + }, + "repayCashMonths": { + "type": "number", + "minimum": 0 + }, + "planningDaySpacing": { + "type": "integer", + "minimum": 0 + }, + "failedMemory": { + "type": "integer", + "minimum": 0 + }, + "partsDeferYears": { + "type": "number", + "minimum": 0, + "maximum": 10 + } + }, + "required": [ + "intervalDays", + "maxCandidates", + "maxProjectsPerMonth", + "candidateMaxDistanceKm", + "candidateMinDistanceKm", + "pathSlopePenalty", + "pathWaterPenalty", + "steepPenalty", + "steepGradeFactor", + "pathMarginRetryKm", + "trainsPerLine", + "wagonsPerTrain", + "cashReserveMonths", + "revenueHorizonYears", + "maxRejectedShare", + "maxConcurrentProjects", + "evaluateTop", + "pathMarginKm", + "simplifyToleranceM", + "stationOffsetsM", + "depotOffsetM", + "platforms", + "hubPlatforms", + "assumedEfficiency", + "speedFactor", + "dwellMinutes", + "maintenanceCostShare", + "trackUpkeepPerKmPerYear", + "maxTrainsPerLine", + "addTrainWaitingTrips", + "minCommuters", + "commuterCoverage", + "hubShare", + "noPartsFactor", + "townBonus", + "townRoiFactor", + "repayCashMonths", + "planningDaySpacing", + "failedMemory", + "partsDeferYears" + ], + "additionalProperties": false }, "personalities": { "type": "array", @@ -74,6 +283,57 @@ }, "minItems": 3 }, + "bots": { + "type": "array", + "items": { + "type": "object", + "properties": { + "id": { + "type": "string", + "pattern": "^[a-z][a-z0-9_]*$" + }, + "name_it": { + "type": "string", + "minLength": 1 + }, + "roiThreshold": { + "type": "number", + "minimum": 0, + "maximum": 1 + }, + "loanShareOfCredit": { + "type": "number", + "minimum": 0, + "maximum": 1 + }, + "targetsPlayer": { + "type": "boolean" + }, + "buysShares": { + "type": "boolean" + }, + "maintenancePolicy": { + "type": "string", + "enum": [ + "economy", + "standard", + "thorough" + ] + } + }, + "required": [ + "id", + "name_it", + "roiThreshold", + "loanShareOfCredit", + "targetsPlayer", + "buysShares", + "maintenancePolicy" + ], + "additionalProperties": false + }, + "minItems": 1 + }, "companyNames": { "type": "array", "items": { @@ -119,6 +379,57 @@ ], "additionalProperties": false }, + "trading": { + "type": "object", + "properties": { + "enabled": { + "type": "boolean" + }, + "minMargin": { + "type": "number", + "minimum": 0, + "maximum": 5 + }, + "priceSlack": { + "type": "number", + "minimum": 0, + "maximum": 1 + }, + "minSellPriceShare": { + "type": "number", + "minimum": 0, + "maximum": 3 + }, + "maxUnits": { + "type": "integer", + "minimum": 1 + }, + "maxTradesPerMonth": { + "type": "integer", + "minimum": 0 + }, + "cashShare": { + "type": "number", + "minimum": 0, + "maximum": 1 + }, + "cashReserveMultiple": { + "type": "number", + "minimum": 0 + } + }, + "required": [ + "enabled", + "minMargin", + "priceSlack", + "minSellPriceShare", + "maxUnits", + "maxTradesPerMonth", + "cashShare", + "cashReserveMultiple" + ], + "additionalProperties": false + }, "market": { "type": "object", "additionalProperties": { @@ -137,7 +448,9 @@ "companyNames", "colors", "market", - "renewal" + "renewal", + "trading", + "bots" ], "additionalProperties": false } diff --git a/data/schema/balance.schema.json b/data/schema/balance.schema.json index ca3bb69..b3a7de6 100644 --- a/data/schema/balance.schema.json +++ b/data/schema/balance.schema.json @@ -242,16 +242,68 @@ }, "world": { "type": "object", - "additionalProperties": { - "type": [ - "number", - "integer", - "boolean", - "array", - "object", - "string" - ] - } + "properties": { + "amplitude": { + "type": "number", + "minimum": 0, + "maximum": 0.5 + }, + "periodYears": { + "type": "number", + "exclusiveMinimum": 0 + }, + "volumeShare": { + "type": "number", + "minimum": 0, + "maximum": 10 + }, + "baselinePerDay": { + "type": "number", + "minimum": 0 + }, + "elasticity": { + "type": "number", + "exclusiveMinimum": 0, + "maximum": 10 + }, + "shockChancePerYear": { + "type": "number", + "minimum": 0, + "maximum": 1 + }, + "shockMin": { + "type": "number", + "minimum": 0, + "maximum": 1 + }, + "shockMax": { + "type": "number", + "minimum": 0, + "maximum": 1 + }, + "shockDecayDays": { + "type": "number", + "exclusiveMinimum": 0 + }, + "priceFloor": { + "type": "number", + "minimum": 0, + "maximum": 1 + } + }, + "required": [ + "amplitude", + "periodYears", + "volumeShare", + "baselinePerDay", + "elasticity", + "shockChancePerYear", + "shockMin", + "shockMax", + "shockDecayDays", + "priceFloor" + ], + "additionalProperties": false }, "historyDays": { "type": "integer", diff --git a/docs/ARCHITECTURE.md b/docs/ARCHITECTURE.md index e2c2d66..9be3f97 100644 --- a/docs/ARCHITECTURE.md +++ b/docs/ARCHITECTURE.md @@ -8,7 +8,7 @@ Questo documento descrive come è fatto il codice. Va aggiornato a ogni fase: le RailEnterprise.Core (net10.0; net8.0) simulazione deterministica, dati, mappa, economia, rete, salvataggi RailEnterprise.Protocol (net10.0; net8.0) frame binari, messaggi, SpanWriter/SpanReader → Core RailEnterprise.Server (net10.0, Web SDK) Kestrel, WebSocket, GameLoop, API HTTP, autosave → Core, Protocol -RailEnterprise.Tools (net10.0) railenterprise-tools: validate-data, genmap, profile, simulate, bench, smoke, replay → Core, Protocol +RailEnterprise.Tools (net10.0) railenterprise-tools: validate-data, genmap, profile, simulate, balance, bench, smoke, replay → Core, Protocol RailEnterprise.Tests (net10.0) harness interno, test di unità, scenari → Core, Protocol, Server client/RailEnterprise.Client (Godot .NET) rendering, input, UI; anteprime con Core → Core, Protocol ``` @@ -70,7 +70,7 @@ Sistemi implementati (F1–F5), nella loro posizione: - Ogni sistema implementa `ISimSystem.Step(WorldContext ctx)`; i sistemi giornalieri o mensili controllano `ctx.IsNewDay` / `ctx.IsNewMonth` e ritornano subito negli altri tick: nei 239 tick su 240 lavora solo `TrainSystem`. - `SystemPipeline.Profile` misura tempo e allocazioni per sistema (usato da `bench`). - `WorldContext` espone il mondo, i dati e il calendario; gli eventi in uscita (notifiche, notizie) vanno in `World.Events`, che il server svuota. -- I comandi arrivano in una coda; il server la riempie dai socket e il sistema `Commands` la drena a inizio tick. Le IA eseguono i loro comandi direttamente con `CommandProcessor` dal sistema `AiAgents` (stesse validazioni, esito immediato, numeri di sequenza ≥ 0x80000000, non registrati per il replay: le IA si rigiocano da sole). Per il replay si registrano `(tick, comando)` in `World.CommandLog`. +- I comandi arrivano in una coda; il server la riempie dai socket e il sistema `Commands` la drena a inizio tick. Le IA eseguono i loro comandi direttamente con `CommandProcessor` dal sistema `AiAgents` (stesse validazioni, esito immediato, numeri di sequenza ≥ 0x80000000, non registrati per il replay: le IA si rigiocano da sole). Il bot giocatore del banco di bilanciamento (`World.PlayerBot`, ADR 0025) usa lo stesso agente per la compagnia del giocatore, prima delle IA, e non è salvato. Per il replay si registrano `(tick, comando)` in `World.CommandLog`. - I flussi pseudo-casuali dei sottosistemi si ottengono con `World.Stream(nome)` (derivati dalla radice con `Rng.Fork`, salvati per nome). ## 4. Determinismo diff --git a/docs/STATE.md b/docs/STATE.md index d1933d4..909da39 100644 --- a/docs/STATE.md +++ b/docs/STATE.md @@ -65,7 +65,7 @@ Aggiornato alla fine di ogni fase (guida, sezione 18). - Protocollo: riepilogo di manutenzione nei record (blocco 1), `RequestDetail` (10), `MaintenanceCard` (124), `WorkshopRegister` (125), `EmploymentReport` con depositi, motivi e convenzioni, `MaintenanceAlert` dagli avvisi. - Client: pannelli «Officine» (politica della flotta, avvisi, flotta per condizione, cartella di manutenzione con componenti e storico, Registro officina, scorta di ricambi, mappa di calore della condizione) e «Impieghi» (Registro degli impieghi con convenzioni da accettare o rifiutare); schede di treno, industria e città con i dati nuovi; schermate in `docs/screenshots/f4-*.jpg`. - Test di 14.5 su manutenzione (rischio monotono, usura monotona nei fattori, condizione che non sale senza interventi, tagliando/revisione/ispezione con la condizione attesa, pianificatore sopra 30 con politica Standard e ricambi) e pendolarismo; guasto grave con soccorso e riserva, deragliamento, ricambi dal porto, politiche, salvataggio a metà officina, convenzioni, registro, dettagli via WebSocket. -- Accettazione F4 (rete di Valdoria con officina a Valdoria e due treni per linea): senza la linea dei ricambi la flotta scende sotto 40 al giorno 697 con 12 guasti (19,5 per milione di km di servizio); con la linea dal Porto di Levante resta sopra 73 con 3 guasti (3,2 per milione di km). +- Accettazione F4 (rete di Valdoria con officina a Valdoria e due treni per linea): senza la linea dei ricambi la flotta scende sotto 40 al giorno 697 con 12 guasti (19,5 per milione di km di servizio); con la linea dal Porto di Levante resta sopra 73 con 3 guasti (3,2 per milione di km). Dopo la taratura del mercato della F6 (ADR 0025): senza la linea 39, sotto 40 dal giorno 731, 10 guasti (18,9 per milione di km); con la linea 73 e 3 guasti. - 102 test. ### F5 — Industrie, IA, borsa e scalate @@ -207,11 +207,23 @@ Aggiornato alla fine di ogni fase (guida, sezione 18). - interfaccia: riquadro non modale in basso a sinistra della mappa (riducibile, non copre barra degli strumenti né pannello destro), contorno ambra animato sull'elemento (ritagliato dai contenitori a scorrimento, che lo portano in vista; del tutto nascosto si usa il ripiego), pulsanti che non prendono il fuoco (Invio e spazio restano alla partita), Avanti per i passi informativi, Salta passo, Chiudi tutorial, «Fatto: …» al completamento; F1 nasconde o riapre; nella schermata di connessione (`ConnectScreen`, sotto «Connetti e riprendi») la casella «Mostra il tutorial» (attiva alla prima partita, vale per la partita che si apre) e il pulsante «Tutorial» (partita locale di prova sempre nuova in `user://tutorial-server`, separata da quella del giocatore, dal primo passo); con una partita locale già salvata la casella parte spenta; tutorial non caricabile: avviso nella partita; - avanzamento per partita in `user://settings.cfg` (sezione `tutorial`, chiave da origine della partita, seme, lato della mappa, anno d'inizio, regione e compagnia del Welcome, mai l'impronta del terreno che cambia giocando): si riprende dopo il caricamento, chiuso o completato resta nascosto salvo la casella spuntata; il pilota automatico non crea il tutorial (schermate invariate); Core, Protocol, Server e salvataggi invariati; - testi italiani e inglesi in `strings.csv`; test (`Client/TutorialTests.cs`, 10, sulla logica collegata al progetto dei test): copione reale valido e completo, traduzioni presenti, pannelli allineati a `Hud.Tool` ed elementi risolti da `GameScreen`, condizioni con la base del passo, avanzamento, salta e chiudi, codifica e ripresa, piano di apertura, chiave stabile con un'impronta del terreno diversa e separata per origine, base del passo al completamento del precedente, validazione dei copioni sbagliati (anche con `null`), prima partita simulata che percorre tutto il copione. 228 test (208 senza i lenti); interfaccia non provata in Godot (qui manca l'editor). -- Restano della F6: bilanciamento con i bot. + - bilanciamento con i bot su `simulate` (issue #47, ADR 0025): + - obiettivi O1–O14 scritti nell'ADR prima della taratura, ciascuno con il suo motivo nella guida; verificati anche sui semi 4–9, mai usati nella taratura; + - `railenterprise-tools balance` (semi × difficoltà × bot × anni, in parallelo, rapporto deterministico): `rapporto.txt` con gli obiettivi e la sintesi (livelli per anno, patrimonio, rating, fallimenti, interessi, prezzi/base min/medio/max, margini dei trasformatori, coperture, ampliamenti, crescita delle città, veicoli superati, mesi senza reti nuove in attesa dei ricambi, affari di compravendita), `anni.csv` (anni chiusi, dicembre compreso), `mesi.csv`, `prezzi.csv`, `esecuzioni.csv`, `tempi.txt`; `simulate --bot `; + - bot giocatore (`PlayerBot`): l'agente delle IA con le personalità di `ai.json → bots` (`bot_competent`, `bot_prudent`) alla guida della compagnia del giocatore; pianifica per primo; non salvato e fuori dall'hash (il formato dei salvataggi non cambia); + - le IA (e i bot) usano la compravendita in proprio (supera ADR 0016 §9): vendita delle scorte, arbitraggio nel bacino o verso le stazioni raggiungibili dalle linee merci, con margine minimo, tetti, prezzi limite e un budget mensile per tutti gli affari in `ai.json → trading`; + - agente corretto: un trasformatore è una fonte solo con gli input alimentati (prima i bot fallivano su linee che si svuotavano finite le scorte iniziali); la linea dei ricambi di una rete nuova esce dal budget iniziale se l'utile la ripaga prima che finisca la dotazione del deposito (stimata dai tagliandi dei treni) e comunque entro `planning.partsDeferYears` (3 anni); in attesa di quella linea l'agente non apre reti nuove, al più per `partsDeferYears`; + - dati: `market.world.volumeShare` 0,5 → 1,0 ed `elasticity` 1,0 → 2,5; `planning.townBonus` 1,8 → 3,0 e `townRoiFactor` 0,5 → 0,35; limiti espliciti negli schemi per tutti i valori di `planning` e `market.world`; + - risultato sulla matrice predefinita (24 esecuzioni da 12 anni): obiettivi raggiunti da 4 a 7 su 13 (O3 non valutabile: il bot non costruisce in «Magnate» e «Ferro e sangue»); livello 2 del bot competente in «Imprenditore» al 4° anno (mediana, prima 7°); nessun fallimento dei bot nelle partite giocate in «Apprendista» e «Imprenditore»; medie partita-bene fuori da 0,7–1,6 da 113 a 3 su 180; mesi-bene nella fascia in «Imprenditore» dal 35 % al 93,5 %. Sui semi 4–9 (48 esecuzioni) 7 su 13: O1 non tiene (livello 2 al 4° anno in 3 semi su 6, poi 8°, 10°, mai), O11 sì (56 %). Restano aperti O1 sui semi di verifica, O6–O7 (beni lavorati sopra 1,6 nelle difficoltà basse), O8 (margini dei trasformatori che vendono positivi nel 62 % dei mesi, prima della taratura 75 %: i prezzi più bassi dei beni lavorati li hanno assottigliati), O9–O10 (servono linee pendolari), O11 sui semi 1–3 e in «Ferro e sangue»; + - correzioni della revisione (ADR 0025, sezione omonima): trasformatori «che vendono» con vendite nell'ultimo trimestre (non `RevenueEma > 0`), O6 per partita, O7 per difficoltà con la fascia della volatilità, O3–O5 sulle sole partite giocate, O11 sulle IA del 3° anno, interessi di dicembre, obiettivi del mondo su una partita per seme e difficoltà, mediana sui due valori centrali con un numero pari di semi, budget della compravendita mensile, blocco dei ricambi limitato alle reti nuove e nel tempo, rinvio della linea dei ricambi legato alla dotazione (sui semi di verifica la regola di prima faceva fallire il bot nel seme 9); + - accettazione F4 legata al mercato attraverso la produzione e i guasti: flotta minima senza linea 39 (sotto 40 dal giorno 731), 10 guasti; con la linea 73 e 3 guasti; con altre elasticità 42 (1,0), 43 (2,0), 41 (3,0): un'unità di margine (ADR 0025); + - test: `Balance/BalanceTests.cs`, 5: rapporto deterministico con due mondi in parallelo, determinismo con quattro mondi da 128 km in parallelo, livello 2 e compravendita (lento), bot che gioca con i comandi e non entra nel salvataggio, compravendita dell'agente nello scenario, banco ridotto lento sui semi 4–9 («Imprenditore», 6 anni) su O5, O12–O14 e almeno un livello 2; `DataTests.SchemaBoundsTheBalanceTuning`; `EconomyTests.PriceRisesWhenDemandExceedsSupply` con soglia 1,25 (il mondo assorbe parte dello squilibrio). + Con il bilanciamento: 244 test (222 senza i lenti), suite completa ~5 minuti. +- Restano della F6: export Windows con server in `server/` e rilascio v0.7.0. ## Prossimo passo -- F6: bilanciamento con i bot su `simulate`; poi rilascio v0.7.0. +- F6: export Windows con server in `server/` e rilascio v0.7.0. ## Limiti noti @@ -225,14 +237,13 @@ Aggiornato alla fine di ogni fase (guida, sezione 18). - Mercato globale (ADR 0015): la previsione segue solo la componente mondiale (ciclo e shock), non domanda e offerta della mappa; «Dove conviene vendere» dà il prezzo alla destinazione, senza il costo del trasporto. - Scalata (ADR 0018): il livello non scende; lo storico del patrimonio ha un punto all'anno (più la fondazione e oggi); il capitale iniziale mostrato è quello della difficoltà; il valore contabile si aggiorna a inizio mese, mentre cassa, partecipazioni e debiti sono del giorno; i salvataggi delle versioni 1–5 ripartiscono il totale degli attivi in proporzione alle voci del giorno di caricamento fino al ricalcolo del mese; il pannello non è ancora stato provato in Godot (qui manca l'editor). - In F3 tutte le sessioni guidano la compagnia del giocatore (ADR 0009). -- Il bilanciamento economico è provvisorio (F6): nello scenario l'acciaieria cresce di livello ogni due trimestri finché la linea operai non satura; il prezzo del minerale sale oltre 1,5 volte il base e il margine dei trasformatori diventa negativo quando la domanda supera l'offerta delle miniere. +- Bilanciamento (ADR 0025): sui semi di verifica 4–9 il bot competente in «Imprenditore» arriva al livello 2 al 4° anno in 3 semi su 6 e poi all'8°, al 10° o mai (O1 non tiene fuori dai semi della taratura); i beni lavorati (acciaio, legname, materiali edili, manufatti) restano a lungo sopra 1,6 volte il base in «Apprendista» e «Imprenditore» (93 % dei mesi-bene nella fascia contro il 95 %); i trasformatori che vendono hanno margine positivo solo nel 62–75 % dei mesi, più sottile di prima della taratura perché i beni lavorati costano meno; con le sole linee merci le industrie servite lavorano a circa 0,36 (copertura dei lavoratori 0,36) e le città calano dello 0,9 % l'anno; in «Ferro e sangue» (e quasi sempre in «Magnate») il bot non trova una prima rete sopra la soglia del ROI, quindi O3 non è valutabile, e poche IA partono entro il 3° anno; l'accettazione F4 ha un'unità di margine e oscilla con i parametri del mercato (42 / 43 / 39 / 41 con elasticità 1 / 2 / 2,5 / 3); le linee urbane che servono al livello passano anche con un ROI sotto il tasso dei prestiti; nello scenario l'acciaieria cresce ancora ogni due trimestri finché la linea operai non satura (sulla mappa generata 0,3 ampliamenti per industria servita all'anno). - La lunghezza dei marciapiedi non è modellata; i segnali sono solo a blocco fisso (niente segnali di percorso). - Comandi ancora `NotImplemented`: concessioni, contratti, ricerca, regioni (fasi F6–F7). - Manutenzione (ADR 0010): il viaggio verso l'officina si stima in linea d'aria; un treno rimorchiato completa il tratto in corso prima di dirigersi all'officina; con un solo treno su una linea di pendolari e un deposito senza personale la copertura cala durante gli interventi (servono riserve e personale); la mappa dei flussi dei pendolari (frecce blu, opzionale nella guida) non è ancora disegnata. - Una rete a binario semplice con pochi binari di stazione può ancora bloccarsi se tutti i binari alle due estremità sono occupati da treni che devono incrociarsi (stallo di capacità segnalato al giocatore come «possibile stallo»): la rete dell'accettazione F4 è dimensionata di conseguenza. -- IA (ADR 0013): su mappe da 128 km in «Magnate» di solito una o due IA crescono (livello 2–3 in 15 anni) mentre le altre restano piccole o falliscono quando la regione non offre candidati con ROI sopra soglia; nel 1850 i grandi fiumi dividono la mappa in regioni fino ai ponti in ferro. Le IA non comprano ancora industrie se non dal livello 3 e non usano la compravendita in proprio (ADR 0016: da aggiungere ai candidati degli agenti con il bilanciamento della F6). +- IA (ADR 0013): su mappe da 128 km in «Magnate» di solito una o due IA crescono (livello 2–3 in 15 anni) mentre le altre restano piccole o falliscono quando la regione non offre candidati con ROI sopra soglia; nel 1850 i grandi fiumi dividono la mappa in regioni fino ai ponti in ferro. Le IA non comprano ancora industrie se non dal livello 3; la compravendita in proprio (ADR 0025) guarda solo i venditori del bacino delle proprie stazioni e i compratori raggiungibili dalle linee merci, senza costruire linee apposta; costruiscono di rado linee pendolari. - Borsa (ADR 0012): per le compagnie piccole il prezzo per azione è di pochi centesimi e il premio di un'offerta ha la granularità di un centesimo; antitrust e finanziamenti statali arrivano in F7. -- Prezzi, soglie dei livelli e taratura economica restano provvisori fino al bilanciamento della F6. ## Misure di prestazione @@ -257,3 +268,7 @@ Aggiornato alla fine di ogni fase (guida, sezione 18). | Pilota automatico del client con i pannelli F4 | ~90 s, 12 schermate | F4 | | Suite di test (120, parallela su 4 core, con i test lenti delle IA) | ~137 s (accettazione F5 70 s) | F5 | | `simulate --years 15` su 128 km «Magnate» con 3 IA | ~60 s | F5 | +| `balance` matrice predefinita (24 esecuzioni da 12 anni su 128 km, 12 in parallelo) | 543 s; 184 s per esecuzione in media, 411 s la più lunga | F6 | +| `balance --seeds 4,5,6,7,8,9` (48 esecuzioni da 12 anni su 128 km, 12 in parallelo) | 597 s; 124 s per esecuzione in media, 330 s la più lunga | F6 | +| Suite di test (244, parallela su 12 core, con i lenti) | ~5 minuti | F6 | +| `balance --difficulties imprenditore --years 8` (6 esecuzioni) | ~85 s | F6 | diff --git a/docs/adr/0016-compravendita-in-proprio.md b/docs/adr/0016-compravendita-in-proprio.md index ef9fa08..2eb6404 100644 --- a/docs/adr/0016-compravendita-in-proprio.md +++ b/docs/adr/0016-compravendita-in-proprio.md @@ -95,7 +95,7 @@ invarianti. «Compravendita in proprio» del pannello, quando sbloccato, sceglie stazione, quantità e destinazione per la merce selezionata e manda i comandi con un tetto del 10 % sopra (o un minimo del 10 % sotto) il prezzo mostrato: è una scelta d'interfaccia, il server ricalcola tutto. -9. **IA.** Le compagnie IA non commerciano ancora: i loro candidati restano linee e treni (ADR 0013). +9. **IA.** Le compagnie IA non commerciano ancora: i loro candidati restano linee e treni (ADR 0013). *Superato dall'ADR 0025: le IA commerciano con una regola mensile deterministica (`ai.json → trading`).* ## Conseguenze diff --git a/docs/adr/0025-bilanciamento.md b/docs/adr/0025-bilanciamento.md new file mode 100644 index 0000000..d505fb3 --- /dev/null +++ b/docs/adr/0025-bilanciamento.md @@ -0,0 +1,247 @@ +# ADR 0025 — Bilanciamento con i bot su simulate (F6) + +Stato: accettato (F6, issue #47), rivisto dopo la revisione (sezione «Correzioni della revisione»). + +## Contesto + +La sezione 16 chiede per la F6 il «bilanciamento con bot su `simulate`». Fino a qui prezzi, soglie dei +livelli e taratura economica erano provvisori (STATE, «Limiti noti»): il prezzo del minerale saliva oltre +1,5 volte il base, il margine dei trasformatori diventava negativo quando la domanda superava l'offerta +delle miniere, l'acciaieria dello scenario cresceva di livello ogni due trimestri, e in molte partite due +IA su tre non costruivano nulla. Mancavano un banco di prova ripetibile, obiettivi scritti prima di +toccare i numeri e la compravendita in proprio delle IA (ADR 0016 §9). + +## Obiettivi (scritti prima della taratura) + +Gli obiettivi si misurano sulla matrice predefinita del banco (semi 1, 2, 3; le quattro difficoltà; bot +competente e prudente; 12 anni su 128 km) e si verificano sui semi 4–9, mai usati nella taratura. Ognuno ha +un motivo nella guida. Le regole di misura in corsivo sono state precisate dopo la revisione (vedi sotto): +non cambiano le soglie, tolgono i modi in cui un obiettivo passava senza misurare nulla. + +| Id | Obiettivo | Perché | +|---|---|---| +| O1 | Bot competente in «Imprenditore»: livello 2 tra il 3° e il 6° anno (mediana dei semi; *con un numero pari di semi entrambi i valori centrali*) | La difficoltà predefinita (7) deve dare il primo sblocco (fido, squadre, compravendita) dopo le prime linee, non subito e non mai | +| O2 | Bot competente in «Apprendista»: livello 2 entro il 5° anno (mediana, *come O1*) | Capitale doppio, tariffe ×1,15, costi ×0,8: la scalata deve essere più facile | +| O3 | Patrimonio finale mediano del bot competente non crescente da «Apprendista» a «Ferro e sangue» (*solo partite in cui il bot ha almeno una linea; «non valutabile» se in una difficoltà non ne ha mai*) | La tabella della sezione 7 peggiora ogni parametro salendo: la difficoltà deve contare | +| O4 | Nessun fallimento del bot prudente in «Apprendista» e «Imprenditore» (*solo partite giocate*) | Un giocatore prudente non deve finire in bancarotta (12.3: in «Apprendista» non si perde mai) | +| O5 | Nessun fallimento del bot competente in «Apprendista» e «Imprenditore» (*solo partite giocate*) | Le stime dei tooltip (gli stessi `Estimators` delle IA) devono essere affidabili | +| O6 | Media di ogni bene *in ogni partita* entro 0,7–1,6 volte il prezzo base | 6.3: il prezzo segue il ciclo mondiale (A = 0,12) con gli squilibri della mappa; i limiti 0,3–3 sono di sicurezza, non lo stato normale | +| O7 | *In ogni difficoltà* almeno il 95 % dei mesi-bene entro 0,7–1,6 volte il base, *fascia allargata in proporzione alla volatilità del mercato della difficoltà quando è oltre 1* | Come O6, mese per mese: gli shock (fino a 0,3 × volatilità) possono uscire per poco; in «Magnate» e «Ferro e sangue» la sezione 7 moltiplica A e shock per 1,3 e 1,6 e il solo prezzo mondiale arriva a 1,67 volte il base | +| O8 | Margine medio dei trasformatori che vendono positivo in almeno l'80 % dei mesi (*che vendono = almeno un giorno con vendite nell'ultimo trimestre*) | 6.3: `pf = clamp(1 + 0,5·margine)`: con margini negativi le industrie servite rendono meno proprio quando il trasporto funziona. Si escludono i trasformatori senza vendite, il cui margine va a −1 per costruzione | +| O9 | Efficienza media delle industrie servite almeno 0,6 nella seconda metà della partita | ADR 0004 §5: un'industria isolata parte da circa 0,3; servirla deve almeno raddoppiarla | +| O10 | Popolazione in «Imprenditore» con il bot: crescita media annua almeno −0,5 % | ADR 0004: senza vettori il mondo perde circa l'1 % l'anno; con bot e IA il declino deve almeno dimezzarsi | +| O11 | Almeno la metà delle IA con una linea in esercizio entro il 3° anno (*sulle IA presenti alla fine del 3° anno*) | 12.1: concorrenti che giocano davvero | +| O12 | Bot competente in «Imprenditore»: interessi entro il 20 % dei ricavi dei trasporti (*anno chiuso, dicembre compreso*) | 6.3: il debito è uno strumento, non una rendita della banca | +| O13 | Comandi rifiutati di bot e IA al massimo il 5 % | 14.5 | +| O14 | Invarianti di denaro e merci in ogni esecuzione | 14.5 | + +*Gli obiettivi del mondo (O6–O11) si contano su una partita per seme e difficoltà* (quella del bot +competente): le due partite dei bot con lo stesso seme condividono mappa e IA e, se il bot non costruisce, +sono quasi lo stesso mondo. + +Restano vere le accettazioni: F2 (acciaieria di Valdoria da meno del 40 % a oltre l'80 % in 2 anni), F4 +(`MaintenanceAcceptanceTests`), F5 (un'IA al livello 3 in 15 anni in «Magnate», seme 7). + +## Decisione + +### Banco di prova + +- `railenterprise-tools balance [--seeds 1,2,3] [--difficulties …] [--bots bot_competent,bot_prudent|nessuno] + [--years 12] [--size 128] [--threads n] [--out bilanciamento]` fa giocare, per ogni combinazione seme × + difficoltà × bot, la compagnia del giocatore a un **bot giocatore** insieme alle IA, giorno per giorno, e + scrive `rapporto.txt` (obiettivi O1–O14 e sintesi per difficoltà e bot), `anni.csv` (per compagnia e anno + chiuso: livello, patrimonio, rating, cassa, debito, interessi, ricavi dei trasporti, utile operativo, treni, + linee), `mesi.csv` (prezzi/base, margini dei trasformatori, coperture, efficienza delle servite, popolazione, + quota di veicoli superati), `prezzi.csv`, `esecuzioni.csv` (anno di ogni livello, fallimenti, comandi + rifiutati, IA al 3° anno, mesi senza reti nuove in attesa dei ricambi, affari di compravendita, hash + finale) e `tempi.txt`. L'anno si campiona dopo il primo giorno dell'anno successivo, che chiude il bilancio + con rate e interessi di dicembre (`LastYearEntries`); la partita dura quindi un giorno in più degli anni + chiesti. Le esecuzioni girano in parallelo ma il rapporto segue l'ordine della matrice e non contiene + tempi: stesso seme, stesso rapporto (test, anche con più mondi insieme). `simulate --bot ` gioca una + partita con il bot. +- Il bot giocatore (`PlayerBot`) è l'agente delle IA (stessi comandi, stesse stime) con una personalità di + `ai.json → bots` (`bot_competent`: ROI 10 %, fido al 60 %, manutenzione standard; `bot_prudent`: ROI 18 %, + fido al 25 %, manutenzione accurata). Pianifica lo stesso giorno della prima IA ma prima di lei, come un + giocatore che costruisce dal primo giorno. È uno strumento di prova: non entra nel salvataggio né nell'hash + (ne entrano gli effetti, che passano tutti dai comandi), quindi il formato dei salvataggi non cambia. I + contatori diagnostici dell'agente (`AiState.PartsBlockedMonths`, `Trades`) non sono salvati. +- Tempi della matrice predefinita (24 esecuzioni da 12 anni su 128 km, 12 in parallelo): 543 s in tutto, + 184 s per esecuzione in media, 411 s la più lunga (il codice di prima della taratura: 571 / 180 / 444 s). + Semi di verifica 4–9 (48 esecuzioni): 597 s, 124 s in media. + +### Compravendita delle IA (supera ADR 0016 §9) + +Ogni mese, dopo i progetti, l'agente (IA o bot) vende le scorte dei propri magazzini se il miglior acquirente +del bacino paga almeno `minSellPriceShare` del prezzo globale; se il livello sblocca la compravendita, cerca +per ogni stazione e bene il venditore più economico del bacino e il compratore migliore nello stesso bacino +o in una stazione raggiungibile dalle sue linee merci (`LineGraph`); un affare vale se il margine +(vendita − acquisto)/acquisto è almeno `minMargin`. Quantità: al più `maxUnits`, la merce disponibile, lo +spazio del magazzino, quanto ricevono i compratori e il budget del mese, la quota `cashShare` della cassa +oltre `cashReserveMultiple` volte la riserva, che vale per tutti gli affari del mese insieme (ogni acquisto +lo riduce di quanto è costato). Gli affari si ordinano per utile (poi stazione, bene, destinazione) e se ne +fanno al più `maxTradesPerMonth`, uno per stazione e bene, con prezzo massimo e minimo a ±`priceSlack` dalla +quotazione; nello stesso bacino si rivende subito (solo alle industrie se nel bacino c'è un hub, che compra e +vende con la stessa capacità mensile, e ricontrollando lo spazio dei compratori, che due stazioni vicine +possono condividere), altrimenti si spedisce. Parametri in `ai.json → trading`; il validatore chiede +`minMargin > 2·priceSlack`. + +### Regole dell'agente corrette con il banco + +1. **Trasformatori senza input** (causa dei fallimenti dei bot): una linea che parte da un'industria di + trasformazione ne stimava la produzione con l'efficienza del giorno, alta all'inizio per scorte e copertura + iniziali; finite le scorte l'impianto si fermava e la linea non incassava più nulla. Ora un trasformatore è + una fonte solo se ogni suo input è alimentato (una stazione in esercizio lo serve, o un produttore di quel + bene è nel raggio del trasporto locale). +2. **Linea dei ricambi rimandata**: una rete nuova lontana dai ricambi metteva subito nel budget anche la linea + dei ricambi (spesso più cara della linea stessa) e in «Imprenditore» il bot non costruiva mai. Ora la linea + dei ricambi entra sempre nel ROI ma esce dal budget iniziale se l'utile atteso la ripaga prima che finisca + la dotazione iniziale del deposito, e comunque entro `planning.partsDeferYears` (3 anni). La durata della + dotazione si stima dai tagliandi dei treni previsti: `initialSpareParts` (25) diviso per veicoli × tagliandi + all'anno (360 / (180 giorni × `intervalFactor` della politica)) × ricambi del tagliando; per un treno di + locomotiva e 5 carri sono 12 ricambi l'anno con la politica standard (circa 2 anni) e 17 con quella accurata + (circa 1,5 anni); riparazioni e revisioni non sono contate, quindi la stima è per eccesso. Finché un deposito + in esercizio aspetta la sua linea e la cassa non basta, l'agente non apre reti nuove (progetti con un + deposito nuovo); le linee che partono da un deposito esistente restano possibili. Il blocco vale al più + `partsDeferYears` dall'apertura della rete; poi l'agente torna a espandersi come prima. Il banco conta i + mesi di blocco: nella matrice predefinita 0–8 per il bot competente in «Imprenditore», al più 49 in tutto + per le tre IA di «Apprendista» in 12 anni. + +### Taratura dei dati + +| File | Valore | Prima | Dopo | Motivo | +|---|---|---|---|---| +| `balance.json` | `market.world.volumeShare` | 0,5 | 1,0 | il resto del mondo scambia quanto la mappa: gli squilibri locali spostano meno il prezzo (O6, O7) | +| `balance.json` | `market.world.elasticity` | 1,0 | 2,5 | domanda e offerta del mondo reagiscono di più al prezzo e lo riportano verso il ciclo; vedi «Accettazione F4» per il legame con la flotta | +| `ai.json` | `planning.townBonus` | 1,8 | 3,0 | quando il livello successivo chiede città collegate, le linee verso le città passano davanti alle merci (O1) | +| `ai.json` | `planning.townRoiFactor` | 0,5 | 0,35 | idem: soglia del ROI delle linee urbane al 35 % di quella della personalità | +| `ai.json` | `planning.partsDeferYears` | — | 3,0 | nuovo, regola 2 | +| `ai.json` | `trading`, `bots` | — | nuovi | compravendita e bot giocatore | + +Tutti i valori di `ai.json → planning` e `balance.json → market.world` hanno ora proprietà esplicite con +limiti negli schemi (per esempio `elasticity` > 0, `volumeShare` 0–10, `townRoiFactor` in (0, 1], +`partsDeferYears` 0–10) e il validatore controlla `candidateMinDistanceKm < candidateMaxDistanceKm` e +`shockMin ≤ shockMax`. + +**Linee urbane sotto il tasso dei prestiti.** Con `townRoiFactor` 0,35 la soglia delle linee verso le città, +quando servono al livello, scende al 3,5 % per il bot competente e al 2,8 % per l'IA espansiva, sotto il tasso +base dei prestiti (5 %, 7 %, 9 %), ed `Execute` prende a prestito quanto manca: un progetto finanziato a debito +può rendere meno del suo interesse. È voluto: il valore di queste linee è lo sblocco del livello (fido, squadre, +compravendita), che il ROI non misura. Una soglia minima al tasso del prestito è stata provata: sui semi 1–3 il +bot competente in «Imprenditore» non arriva più al livello 2 entro 6 anni nel seme 3 (prima al 3°) e O1 cade. + +Restano com'erano i valori fissati dalla guida (capitale e fido iniziali, moltiplicatori di difficoltà, k, α, +A, T, limiti 0,3–3, formula del costo dei binari) e le soglie dei livelli. + +### Accettazione F4 ed elasticità del mondo + +La flotta senza ricambi dell'accettazione F4 (soglia: sotto 40 entro 3 anni) dipende dal mercato attraverso la +produzione: i prezzi mondiali cambiano margini e fattore di profitto delle industrie di Valdoria, quindi i carichi +e le attese dei treni, i km percorsi, l'usura e il momento dei guasti (estratti a caso). Il legame non è +monotono: con il mondo a volume pieno la flotta minima senza linea è 42 con elasticità 1,0, 43 con 2,0, 39 con +2,5 e 41 con 3,0. Fra i valori provati solo 2,5 tiene verde la F4, con un'unità di margine: un ritocco del +mercato o degli agenti può farla uscire per caso. Una scelta con margine (37 o meno) non esiste tra i valori +provati; renderla indipendente dal mercato (come lo scenario fa già con gli eventi, ADR 0017 §8) è una modifica +dello scenario dell'accettazione da decidere a parte. + +### Prima e dopo + +«Prima» è il codice e i dati di prima della taratura misurati con il banco di adesso; «dopo» la matrice +predefinita (semi 1–3, quattro difficoltà, due bot, 12 anni, 128 km); «verifica» gli stessi parametri sui +semi 4–9. + +| Metrica | Prima | Dopo (semi 1–3) | Verifica (semi 4–9) | +|---|---|---|---| +| O1 livello 2 del bot competente in «Imprenditore» (anni dei semi) | mai / 5 / 7, mediana 7: no | 4 / 8 / 3, mediana 4: sì | 4 / 8 / 10 / 4 / 4 / mai, mediana 4–8, 3 su 6 nella fascia: no | +| O2 livello 2 del bot competente in «Apprendista» | mediana 1: sì | 2 / 2 / 7, mediana 2: sì | 1 / 4 / 3 / 3 / 3 / 6, mediana 3: sì | +| O3 patrimonio finale mediano del bot competente (Appr. / Impr. / Magn. / Ferro) | ₤ 1.987.362 / 389.784 / — / —: non valutabile | ₤ 4.722.732 / 1.680.803 / — / —: non valutabile | ₤ 2.848.486 / 2.011.836 / 399.208 / —: non valutabile | +| Partite in cui il bot costruisce (competente / prudente; su 12 per bot, 24 nella verifica) | 5 / 2 | 6 / 3 | 13 / 10 | +| O4 fallimenti del bot prudente (Appr. e Impr., partite giocate) | 1 su 2 | 0 su 3 | 0 su 10 | +| O5 fallimenti del bot competente (Appr. e Impr., partite giocate) | 1 su 5 | 0 su 6 | 0 su 12 | +| O6 medie partita-bene fuori 0,7–1,6 (peggiori) | 113 su 180 (minerale 0,31 – alimentari 2,96) | 3 su 180 (minerale 0,70 – materiali edili 1,45) | 8 su 360 (minerale 0,69 – manufatti 1,46) | +| O6 media sull'insieme delle partite, bene più basso e più alto | 0,38 (grano) – 2,77 (alimentari) | 0,77 (bestiame) – 1,42 (materiali edili) | 0,77 (grano) – 1,42 (manufatti) | +| Minerale di ferro / base in «Imprenditore» (min / medio / max) | 0,30 / 0,68 / 1,69 | 0,55 / 0,83 / 1,20 | 0,53 / 0,82 / 1,27 | +| Acciaio / base in «Imprenditore» (min / medio / max) | 1,05 / 2,31 / 3,00 | 1,03 / 1,39 / 1,82 | 0,95 / 1,31 / 1,70 | +| O7 mesi-bene nella fascia (Appr. / Impr. / Magn. / Ferro) | 34,2 / 35,3 / 41,5 / 49,2 % | 94,1 / 93,5 / 98,9 / 99,7 % | 95,0 / 92,8 / 98,4 / 99,6 % | +| O8 mesi con margine medio positivo dei trasformatori che vendono | 74,9 % (margine +0,239) | 61,7 % (margine +0,017) | 74,7 % (margine +0,171) | +| O9 efficienza delle industrie servite, seconda metà | 0,326 | 0,357 | 0,358 | +| Coperture medie input / lavoratori / personale («Imprenditore», bot competente) | 0,80 / 0,36 / 0,43 | 0,80 / 0,36 / 0,43 | 0,79 / 0,35 / 0,42 | +| Ampliamenti per industria servita all'anno («Imprenditore», bot competente) | 0,31 | 0,32 | 0,35 | +| O10 crescita annua delle città in «Imprenditore» | −0,9 % | −0,9 % | −0,9 % | +| O11 IA con una linea entro il 3° anno | 42,4 % (14 su 33) | 39,4 % (13 su 33) | 56,1 % (37 su 66) | +| O12 interessi / ricavi dei trasporti del bot competente in «Imprenditore» | 5,8 % | 4,3 % | 4,3 % | +| O13 comandi rifiutati di bot e IA | 2,7 % (167 su 6.248) | 0,1 % (9 su 6.749) | 0,1 % (15 su 14.794) | +| O14 invarianti di denaro e merci | rispettati | rispettati | rispettati | +| Veicoli superati alla fine dei 12 anni | 0 % | 0 % | 0 % | +| Obiettivi raggiunti (O3 non valutabile) | 4 su 13 | 7 su 13 | 7 su 13 | + +Raggiunti dopo la taratura: O1, O2, O4, O5, O12, O13, O14 sui semi 1–3; O2, O4, O5, O11, O12, O13, O14 sui semi +di verifica. + +### Obiettivi non raggiunti (restano aperti) + +- **O1 sui semi di verifica**: il livello 2 arriva al 4° anno in 3 semi su 6, poi all'8°, al 10° o mai; sui + semi della taratura la mediana poggiava su una partita (4 / 8 / 3). La taratura di `townBonus` e + `townRoiFactor` non generalizza abbastanza: la scalata dipende molto dalla mappa. +- **O3**: in «Ferro e sangue» (e in «Magnate» sui semi 1–3) il bot non costruisce mai: con ₤ 150.000 e + ₤ 100.000 e i costi ×1,25 e ×1,5 nessuna prima rete supera il ROI della personalità. L'obiettivo non si + può valutare finché il bot non gioca in ogni difficoltà. +- **O6, O7**: i beni lavorati (acciaio, legname, materiali edili, manufatti) stanno a lungo sopra 1,6 volte il + base in «Apprendista» e «Imprenditore», e il minerale scende a 0,7 in qualche partita; un'elasticità più alta + li rientrerebbe ma la F4 non lo permette (sopra). +- **O8**: misurato sui trasformatori che hanno venduto nell'ultimo trimestre, il margine è peggiorato con la + taratura (da +0,24 a +0,02 di media sui semi 1–3): prima i beni lavorati costavano 2–3 volte il base e i + trasformatori che vendevano guadagnavano molto; riportati i prezzi verso il base, il margine resta sottile + e negativo in quasi 4 mesi su 10. La conclusione della prima versione («logistica, non prezzo», 5,6 % dei + mesi con margine −0,70) veniva da una misura sbagliata (RevenueEma > 0, che dopo la prima vendita non torna + più a zero e contava i trasformatori fermi da anni). Correggerlo vuol dire ritoccare prezzi base o ricette dei + beni lavorati, una decisione a parte. +- **O9, O10**: con le sole linee merci l'efficienza resta limitata dai lavoratori (copertura 0,36): servono + linee pendolari, che bot e IA costruiscono di rado; la crescita delle città resta quella senza vettori. +- **O11** sui semi 1–3 (39 %) e in «Ferro e sangue» (2 IA su 15 entro il 3° anno sui semi 1–3, 8 su 30 su quelli + di verifica). +- La crescita dell'acciaieria dello scenario «ogni due trimestri» non si ripete sulla mappa generata (0,3 + ampliamenti per industria servita all'anno); il punteggio di crescita della sezione 6 resta com'è. + +## Correzioni della revisione + +- O8 contava come «trasformatori che vendono» quelli con `RevenueEma > 0`: una media mobile esponenziale non + torna più a zero dopo la prima vendita. Il banco ricava ogni giorno le vendite dalla media mobile e conta i + trasformatori con vendite nell'ultimo trimestre (`growth.quarterDays`), come `ServedWithin` per le servite. +- La taratura era stata fatta e verificata sugli stessi tre semi: ora la verifica gira anche sui semi 4–9, il + rapporto dà gli anni di ogni seme e quanti stanno nella fascia, e con un numero pari di semi la mediana vale + solo se vale per i due valori centrali. Il test lento usa i semi 4–9. +- O6 si misura per partita e bene (la peggiore media), come dice l'obiettivo; la media sull'insieme resta nel + rapporto. +- Gli interessi di dicembre mancavano: l'anno si campiona dopo il giorno che chiude il bilancio. +- O3–O5 contavano anche le partite in cui il bot non costruisce: ora solo quelle giocate, e O3 è «non + valutabile» se in una difficoltà il bot non gioca mai (prima passava perché il capitale iniziale decresce con + la difficoltà). +- O7 era misurato su tutte le difficoltà insieme con la stessa fascia, mentre la sezione 7 moltiplica la + volatilità del mercato in «Magnate» e «Ferro e sangue»: ora per difficoltà, con la fascia allargata. +- O11 divideva per le IA della fine partita (anche i concorrenti nati dopo il 3° anno) e mostrava «no» per + partite più corte di 3 anni: ora divide per le IA presenti alla fine del 3° anno e dice «non eseguito». +- Gli obiettivi del mondo contavano due volte le partite dei due bot con lo stesso seme: ora una per seme e + difficoltà. +- Il test di determinismo confrontava un solo mondo con uno o due thread: ora due mondi in parallelo (veloce) e + quattro mondi da 128 km su due difficoltà per 3 anni con quattro thread, con un bot al livello 2 nel primo + anno e 28 affari di compravendita (lento). +- I valori di taratura non avevano limiti negli schemi: ora sì (sopra). +- Il blocco per la linea dei ricambi fermava ogni progetto nuovo, senza limite di tempo: ora ferma solo le reti + nuove ed entro `partsDeferYears`. La giustificazione dei 3 anni («la dotazione regge») non era vera: ora il + rinvio è legato alla durata stimata della dotazione. Sui semi di verifica la regola di prima faceva fallire il + bot competente nel seme 9 di «Imprenditore» (deposito senza ricambi, flotta ferma, ricavi a zero dal 4° anno); + ora quel bot non costruisce. +- Il budget della compravendita valeva per ogni affare: ora per il mese. +- Il numero delle esecuzioni della matrice predefinita era scritto 72: sono 24. + +## Conseguenze + +- Il banco fa parte della verifica: il test lento `BalanceTests.BenchMeetsTheMainGoals` (semi 4–9, + «Imprenditore», bot competente, 6 anni) controlla O5, O12, O13 e O14 e che almeno un bot arrivi al livello 2; + `ParallelRunsWithTradingGiveTheSameReport` (lento) e `SameSeedGivesTheSameReport` controllano il determinismo + del rapporto con più mondi in parallelo. +- `EconomyTests.PriceRisesWhenDemandExceedsSupply` chiedeva un aumento di 1,5 volte in 120 giorni senza + offerta; con il mondo a volume pieno ed elasticità 2,5 l'aumento è circa 1,36: la soglia passa a 1,25 (resta + la verifica che lo squilibrio alzi il prezzo). +- Restano vere le accettazioni F2, F4 (flotta senza ricambi a 39, sotto 40 dal giorno 731, 10 guasti; con la + linea 73 e 3 guasti) e F5 (un'IA al livello 3 nel 1861 in «Magnate», seme 7). diff --git a/src/RailEnterprise.Core/Data/AiDefs.cs b/src/RailEnterprise.Core/Data/AiDefs.cs index 8ca6959..bcdd56c 100644 --- a/src/RailEnterprise.Core/Data/AiDefs.cs +++ b/src/RailEnterprise.Core/Data/AiDefs.cs @@ -12,7 +12,14 @@ public sealed class AiFile public required AiMarketParams Market { get; init; } /// Rinnovo dei treni con veicoli superati (F6, ADR 0020). public required AiRenewalParams Renewal { get; init; } + /// Compravendita in proprio delle IA (F6, ADR 0016 §9 e ADR 0025). + public required AiTradingParams Trading { get; init; } public required List Personalities { get; init; } + /// + /// Personalità dei «bot giocatore» del banco di bilanciamento (ADR 0025): guidano la compagnia del + /// giocatore con lo stesso agente delle IA; non si assegnano mai alle compagnie IA. + /// + public required List Bots { get; init; } public required List CompanyNames { get; init; } public required List Colors { get; init; } } @@ -77,6 +84,12 @@ public sealed class AiPlanningParams public required int PlanningDaySpacing { get; init; } /// Candidati falliti ricordati per non riprovarli. public required int FailedMemory { get; init; } + /// + /// Una rete nuova lontana dai ricambi parte senza la sua linea dei ricambi (che si costruisce dopo, con + /// i ricavi) solo se l'utile atteso la ripaga entro questi anni; altrimenti la linea entra subito nel + /// budget (ADR 0025). Zero: sempre subito. + /// + public required double PartsDeferYears { get; init; } } /// @@ -94,6 +107,30 @@ public sealed class AiRenewalParams public required int MaxTrainsPerMonth { get; init; } } +/// +/// Compravendita in proprio delle IA (ADR 0016 §9, ADR 0025): una volta al mese, dal livello che la sblocca, +/// l'agente vende la merce dei propri magazzini ai compratori del bacino che pagano almeno +/// del prezzo globale e cerca le occasioni migliori: comprare dai produttori +/// (o dagli hub) del bacino di una sua stazione e vendere nella stessa stazione o in una raggiungibile con le +/// sue linee, quando il margine atteso sulla prossima unità supera . Al più +/// operazioni da unità, con al più +/// della cassa libera oltre volte la riserva. +/// +public sealed class AiTradingParams +{ + public required bool Enabled { get; init; } + /// Margine minimo atteso (vendita − acquisto) / acquisto sulla prossima unità. + public required double MinMargin { get; init; } + /// Scarto ammesso sul prezzo della prossima unità: tetto d'acquisto e minimo di vendita. + public required double PriceSlack { get; init; } + /// Si vende la merce in magazzino solo a chi paga almeno questa quota del prezzo globale. + public required double MinSellPriceShare { get; init; } + public required int MaxUnits { get; init; } + public required int MaxTradesPerMonth { get; init; } + public required double CashShare { get; init; } + public required double CashReserveMultiple { get; init; } +} + /// Comportamento in borsa delle IA (12.1–12.2). public sealed class AiMarketParams { diff --git a/src/RailEnterprise.Core/Data/DataValidator.cs b/src/RailEnterprise.Core/Data/DataValidator.cs index 9533004..3d6bb84 100644 --- a/src/RailEnterprise.Core/Data/DataValidator.cs +++ b/src/RailEnterprise.Core/Data/DataValidator.cs @@ -273,7 +273,15 @@ public static class DataValidator RequireKeys("maintenance.json", "depots.stallsBySize", m.Depots.StallsBySize.Keys, SizeKeys, errors); // --- IA, contratti, regioni - Unique("ai.json", d.Ai.Personalities.Select(p => p.Id), errors); + // personalità delle IA e dei bot giocatore (ADR 0025) in un solo spazio di nomi + Unique("ai.json", d.Ai.Personalities.Select(p => p.Id).Concat(d.Ai.Bots.Select(p => p.Id)), errors); + if (d.Ai.Trading.MinMargin <= 2 * d.Ai.Trading.PriceSlack) + Err("ai.json", "trading.minMargin deve superare il doppio di trading.priceSlack (ogni unità scambiata resta in margine)"); + // i limiti dei singoli valori di taratura (planning, market.world) sono negli schemi (ADR 0025) + if (d.Ai.Planning.CandidateMinDistanceKm >= d.Ai.Planning.CandidateMaxDistanceKm) + Err("ai.json", "planning.candidateMinDistanceKm deve essere minore di candidateMaxDistanceKm"); + if (d.Balance.Market.World.ShockMin > d.Balance.Market.World.ShockMax) + Err("balance.json", "market.world.shockMin non può superare shockMax"); Unique("contracts.json", d.Contracts.Templates.Select(t => t.Id), errors); foreach (var t in d.Contracts.Templates) { diff --git a/src/RailEnterprise.Core/Simulation/Ai/AiAgent.cs b/src/RailEnterprise.Core/Simulation/Ai/AiAgent.cs index 0b74169..a4320b6 100644 --- a/src/RailEnterprise.Core/Simulation/Ai/AiAgent.cs +++ b/src/RailEnterprise.Core/Simulation/Ai/AiAgent.cs @@ -27,14 +27,17 @@ internal sealed class AiAgent private readonly AiPlanningParams _plan; private readonly AiMarketParams _mk; private readonly GridPath _path; + // un deposito in esercizio aspetta la sua linea dei ricambi e la cassa non basta ancora: questo mese + // niente reti nuove (nuovi depositi), le linee che usano un deposito esistente restano possibili + private bool _partsPending; - public AiAgent(World w, WorldContext ctx, AiState s, GridPath path) + public AiAgent(World w, WorldContext ctx, AiState s, GridPath path, AiPersonalityDef? personality = null) { _w = w; _ctx = ctx; _s = s; _c = w.Company(s.Company); - _p = w.Data.Ai.Personalities.FirstOrDefault(p => p.Id == _c.AiPersonality) ?? w.Data.Ai.Personalities[0]; + _p = personality ?? w.Data.Ai.Personalities.FirstOrDefault(p => p.Id == _c.AiPersonality) ?? w.Data.Ai.Personalities[0]; _plan = w.Data.Ai.Planning; _mk = w.Data.Ai.Market; _path = path; @@ -269,7 +272,158 @@ internal sealed class AiAgent RenewFleet(); StockMarket(); BuyIndustries(); - if (!EnsurePartsSupply()) NewProject(); + if (!EnsurePartsSupply()) + { + if (_partsPending) _s.PartsBlockedMonths++; + NewProject(); + } + Trade(); + } + + // ================================================================== compravendita in proprio (ADR 0016, 0025) + + /// Occasione di compravendita: comprare un bene in una stazione e venderlo lì o in un'altra raggiungibile. + private readonly record struct Deal(Station From, Station To, int Good, double BuyPrice, double SellPrice, int Units) + { + public double Profit => Units * (SellPrice - BuyPrice); + } + + /// + /// Compravendita in proprio (ADR 0016 §9, ADR 0025), dopo i progetti: le linee hanno la precedenza sulla + /// cassa. Prima vende la merce dei propri magazzini a chi paga almeno trading.minSellPriceShare del prezzo + /// globale; poi, se il livello lo sblocca, valuta per ogni stazione propria e bene in vendita nel bacino la + /// destinazione migliore (la stazione stessa o una raggiungibile sulle proprie linee con i flag delle + /// fermate) e, se il margine della prossima unità supera trading.minMargin, compra con un tetto e vende + /// subito o spedisce. Regola deterministica: occasioni in ordine di utile atteso, poi stazione, bene e + /// destinazione; al più trading.maxTradesPerMonth al mese, una per stazione e bene. + /// + private void Trade() + { + var t = _w.Data.Ai.Trading; + if (!t.Enabled) return; + var stations = new List(); + foreach (var st in _w.Network.Stations) + { + if (st.Owner == _c.Id && _w.Network.IsAlive(st)) stations.Add(st); + } + if (stations.Count == 0) return; + SellStock(t, stations); + if (t.MaxTradesPerMonth <= 0 || !Tiers.Unlocks(_w, _c).Trading) return; + double budget = Math.Max(0, FreeCash() - Reserve() * t.CashReserveMultiple) * t.CashShare; + if (budget <= 0) return; + + var graph = _w.LineGraphs.For(_w, _c.Id); + int[] reserved = TradingMath.ReservedByStation(_w); + var deals = new List(); + foreach (var from in stations) + { + int freeFrom = TradingMath.FreeSpace(_w, from, reserved[from.Id.Value]); + if (freeFrom <= 0) continue; + for (int g = 0; g < _w.Data.GoodCount; g++) + { + if (_w.Data.Goods[g].Era > _ctx.Year) continue; + var sellers = TradingMath.Sellers(_w, from, g); + if (TradingMath.CheapestSeller(_w, sellers, g, out double buy) is null || buy <= 0) continue; + int available = 0; + foreach (var x in sellers) available += x.Limit; + int affordable = (int)Math.Min(int.MaxValue, budget / (buy * (1 + t.PriceSlack))); + int cap = Math.Min(Math.Min(t.MaxUnits, available), Math.Min(freeFrom, affordable)); + if (cap <= 0) continue; + Consider(deals, t, from, from, g, buy, cap); + var reach = graph.From(from.Id, LineGraph.GoodCargo(g), stopFlags: true); + if (reach.Count == 0) continue; + var keys = new List(reach.Keys); + keys.Sort(); + foreach (int k in keys) + { + var to = _w.Network.Stations[k]; + if (to.Id == from.Id || to.Owner != _c.Id || !_w.Network.IsAlive(to)) continue; + int freeTo = TradingMath.FreeSpace(_w, to, reserved[k]); + if (freeTo > 0) Consider(deals, t, from, to, g, buy, Math.Min(cap, freeTo)); + } + } + } + if (deals.Count == 0) return; + deals.Sort((a, b) => + a.Profit != b.Profit ? b.Profit.CompareTo(a.Profit) + : a.From.Id.Value != b.From.Id.Value ? a.From.Id.Value.CompareTo(b.From.Id.Value) + : a.Good != b.Good ? a.Good.CompareTo(b.Good) + : a.To.Id.Value.CompareTo(b.To.Id.Value)); + int done = 0; + var used = new List<(int Station, int Good)>(); + foreach (var d in deals) + { + if (done >= t.MaxTradesPerMonth) break; + if (used.Contains((d.From.Id.Value, d.Good))) continue; + used.Add((d.From.Id.Value, d.Good)); + string good = _w.Data.Goods[d.Good].Id; + long maxPrice = (long)Math.Ceiling(d.BuyPrice * (1 + t.PriceSlack)); + if (FreeCash() < maxPrice) break; + // il budget del mese (cashShare della cassa oltre la riserva) vale per tutti gli affari insieme + int units = (int)Math.Min(d.Units, budget / maxPrice); + if (units <= 0) continue; + if (d.To.Id == d.From.Id) + { + // un affare precedente può aver riempito un compratore comune a due stazioni vicine + int room = 0; + foreach (var b in TradingMath.Buyers(_w, d.From, d.Good)) + { + if (b.Kind == TradePartyKind.Industry || d.From.Hubs.Count == 0) room += b.Limit; + } + units = Math.Min(units, room); + if (units <= 0) continue; + } + int before = d.From.StockOf(d.Good); + long cashBefore = _c.Cash.Cents; + if (!Do(new BuyGoodsCommand(d.From.Id, good, units, new Money(maxPrice))).Ok) continue; + budget -= cashBefore - _c.Cash.Cents; + int bought = d.From.StockOf(d.Good) - before; + if (bought <= 0) continue; + done++; + _s.Trades++; + if (d.To.Id == d.From.Id) + Do(new SellGoodsCommand(d.From.Id, good, bought, new Money((long)Math.Floor(d.SellPrice * (1 - t.PriceSlack))))); + else + Do(new ShipGoodsCommand(d.From.Id, d.To.Id, good, bought)); + AiSystem.Trace?.Invoke($"{_ctx.Day} {_c.Name}: COMMERCIO {bought} {good} a {d.From.Name} ({d.BuyPrice / 100:0.00}) → {d.To.Name} ({d.SellPrice / 100:0.00})"); + } + } + + /// Aggiunge l'occasione se i compratori della destinazione pagano la prossima unità con il margine minimo. + private void Consider(List deals, AiTradingParams t, Station from, Station to, int good, double buy, int cap) + { + var buyers = TradingMath.Buyers(_w, to, good); + // nello stesso bacino un hub che vende consuma la stessa capacità mensile con cui comprerebbe: + // si rivende solo alle industrie + if (to.Id == from.Id && from.Hubs.Count > 0) buyers = buyers.Where(b => b.Kind == TradePartyKind.Industry).ToList(); + if (TradingMath.BestBuyer(_w, buyers, good, out double sell) is null) return; + if ((sell - buy) / buy < t.MinMargin) return; + int room = 0; + foreach (var b in buyers) room += b.Limit; + int units = Math.Min(cap, room); + if (units > 0) deals.Add(new Deal(from, to, good, buy, sell, units)); + } + + /// Vende la merce dei magazzini propri ai compratori del bacino che pagano almeno la quota minima del prezzo globale. + private void SellStock(AiTradingParams t, List stations) + { + foreach (var st in stations) + { + if (st.StockTotal <= 0) continue; + for (int g = 0; g < _w.Data.GoodCount; g++) + { + int stock = st.StockOf(g); + if (stock <= 0) continue; + double floor = _w.Market.GlobalPrice[g] * t.MinSellPriceShare; + var buyers = TradingMath.Buyers(_w, st, g); + if (TradingMath.BestBuyer(_w, buyers, g, out double price) is null || price < Math.Ceiling(floor)) continue; + // compratori con il magazzino pieno: si riprova il mese dopo invece di farsi rifiutare il comando + int room = 0; + foreach (var b in buyers) room += b.Limit; + if (room <= 0) continue; + Do(new SellGoodsCommand(st.Id, _w.Data.Goods[g].Id, Math.Min(stock, room), new Money((long)Math.Ceiling(floor)))); + } + } } // ================================================================== ricambi (10.2) @@ -334,7 +488,18 @@ internal sealed class AiAgent continue; } AiSystem.Trace?.Invoke($"{_ctx.Day} {_c.Name}: linea dei ricambi per {depot.Name}: {km:0.0} km, capitale {new Money(proposal.Capital)} (budget {new Money(budget)})"); - if (proposal.Capital > budget) return false; + if (proposal.Capital > budget) + { + // si risparmia per la linea (niente depositi nuovi) solo entro planning.partsDeferYears + // dall'apertura della rete; poi l'agente torna a espandersi come prima (ADR 0025) + long opened = long.MaxValue; + foreach (var p in _s.Projects) + { + if (p.Depot == depot.Id && p.StartDay < opened) opened = p.StartDay; + } + if (opened != long.MaxValue && _ctx.Day - opened <= _plan.PartsDeferYears * _w.Calendar.DaysPerYear) _partsPending = true; + return false; + } Execute(proposal, depot.Id); return true; } @@ -632,6 +797,8 @@ internal sealed class AiAgent public Vec2? DepotPos { get; init; } public DepotId ExistingDepot { get; init; } = DepotId.None; public required long Capital { get; init; } + /// Parte del capitale spesa dopo, con i ricavi della linea: la linea dei ricambi del deposito (ADR 0025). + public long DeferredCapital { get; init; } public required double Revenue { get; init; } public required double Costs { get; init; } public required int Trains { get; init; } @@ -671,10 +838,16 @@ internal sealed class AiAgent continue; } AiSystem.Trace?.Invoke($"{_ctx.Day} {_c.Name}: candidato {cand.Kind} bene {cand.Good} {cand.StraightKm:0.0} km: capitale {new Money(proposal.Capital)}, ricavi {Money.FromCentsRounded(proposal.Revenue)}, costi {Money.FromCentsRounded(proposal.Costs)}, ROI {proposal.Roi * 100:0.0} % (soglia {_p.RoiThreshold * 100:0} %, budget {new Money(budget)})"); - if (proposal.Capital > budget) continue; + // la linea dei ricambi entra nel ROI ma si costruisce dopo (EnsurePartsSupply): il deposito parte con la + // sua dotazione di ricambi e la linea si paga con i primi ricavi (ADR 0025) + if (proposal.Capital - proposal.DeferredCapital > budget) continue; + // un deposito aspetta la sua linea dei ricambi: niente reti nuove finché la cassa non basta + if (_partsPending && !proposal.ExistingDepot.IsValid) continue; // ROI sul capitale investito, come nella guida (gli interessi sono una scelta di finanziamento) double roi = proposal.Roi; bool townProject = cand.SourceIsTown || cand.DestIsTown; + // le linee urbane che servono al livello passano con una soglia ridotta, anche sotto il tasso dei prestiti: + // il loro valore è lo sblocco del livello, che il ROI non misura (ADR 0025) double threshold = townProject && NeedTowns() ? _p.RoiThreshold * _plan.TownRoiFactor : _p.RoiThreshold; if (roi < threshold) continue; if (best is null || proposal.Roi > best.Roi) best = proposal; @@ -730,6 +903,8 @@ internal sealed class AiAgent // impianto fermo per un incidente: non si giudica oggi, se ne riparla a evento finito if (capacity <= 0) break; eff = Math.Min(prod.Efficiency / capacity, eff); + // senza chi porta gli input l'impianto vive delle scorte iniziali e poi si ferma (ADR 0025) + if (!InputsFed(prod, servedBy)) eff = 0; } double supply = (double)prod.Def.Capacity(prod.Level) * outputs[o].PerCycle / outputs[0].PerCycle * months * eff; if (supply <= 0) continue; @@ -932,6 +1107,32 @@ internal sealed class AiAgent + Estimators.StationCost(_w, _c, _plan.HubPlatforms) + Estimators.DepotCost(_w, _c, "small") + train; } + /// + /// Un'industria di trasformazione ha ogni input alimentato: da una stazione in esercizio che la + /// serve o, con il trasporto locale attivo, da un produttore di quel bene entro il suo raggio + /// (ADR 0025). Le scorte iniziali e la copertura iniziale piena non bastano a stimarne la resa. + /// + private bool InputsFed(Industry ind, CompanyId[] servedBy) + { + if (servedBy[ind.Id.Value].IsValid) return true; + var lt = _w.Data.Balance.LocalTransport; + foreach (var input in ind.Def.Recipe.Inputs) + { + bool fed = false; + if (lt.Enabled) + { + foreach (var other in _w.Industries) + { + if (other.Closed || other.Level <= 0 || other.Id == ind.Id) continue; + if (!other.Def.Recipe.Outputs.Any(o => o.GoodIndex == input.GoodIndex)) continue; + if (Vec2.Distance(other.Position, ind.Position) <= lt.RadiusKm * 1000) { fed = true; break; } + } + } + if (!fed) return false; + } + return true; + } + /// /// Compagnia che serve (o sta per servire) ciascuna industria: una sua stazione ha l'industria nel /// bacino, anche se la linea è ancora in costruzione (o None). @@ -984,7 +1185,7 @@ internal sealed class AiAgent Vec2? depotPos = null; var existingDepot = supply is { } supplied ? supplied : existingA.IsValid ? ConnectedDepot(existingA) : DepotId.None; if (!existingDepot.IsValid && existingB.IsValid) existingDepot = ConnectedDepot(existingB); - long capital = plan.TotalCost.Cents; + long capital = plan.TotalCost.Cents, deferred = 0; bool depotAtB = false; if (!existingDepot.IsValid) { @@ -999,6 +1200,8 @@ internal sealed class AiAgent long partsCost = PartsLineCost(home, sources); if (partsCost < 0) return Reject("nessuna linea di ricambi possibile per il deposito"); capital += partsCost; + deferred = partsCost; + AiSystem.Trace?.Invoke($"{_ctx.Day} {_c.Name}: linea dei ricambi in conto {new Money(partsCost)}"); } var next = depotAtB ? (polyline.Count > 1 ? polyline[^2] : posA.Value) : (polyline.Count > 1 ? polyline[1] : posB.Value); depotPos = DepotSite(home, next); @@ -1012,6 +1215,7 @@ internal sealed class AiAgent if (!existingB.IsValid) capital += Estimators.StationCost(_w, _c, depotPos is not null && depotAtB ? _plan.HubPlatforms : _plan.Platforms); double km = plan.LengthM / 1000; + AiSystem.Trace?.Invoke($"{_ctx.Day} {_c.Name}: binari {km:0.0} km: opere {plan.WorksCost}, terreni {plan.LandCost}"); VehicleDef? car = cand.Kind == AiProjectKind.Freight ? Estimators.WagonFor(_w, cand.Good, _ctx.Year) : Estimators.CoachFor(_w, cand.Class, _ctx.Year); if (car is null) return null; int cars = supply is not null ? 1 : cand.Kind == AiProjectKind.Freight ? _plan.WagonsPerTrain : Math.Max(1, _plan.WagonsPerTrain / 2); @@ -1043,11 +1247,22 @@ internal sealed class AiAgent + (existingB.IsValid ? 0 : _plan.Platforms * sp.UpkeepPerPlatformPerYear) + (existingDepot.IsValid ? 0 : sp.DepotUpkeepPerYear["small"]) + km * _plan.TrackUpkeepPerKmPerYear; + // la linea dei ricambi si rimanda solo se l'utile della linea la ripaga prima che finisca la dotazione + // iniziale del deposito (tagliandi dei treni previsti con la politica della personalità), e comunque + // entro planning.partsDeferYears (ADR 0025) + if (deferred > 0) + { + var mt = _w.Data.Maintenance; + double servicesPerYear = _w.Calendar.DaysPerYear / (mt.Intervals.ServiceDays * mt.Policy(_p.MaintenancePolicy).IntervalFactor); + double partsPerYear = trains * (1 + cars) * servicesPerYear * mt.Intervention("service").SpareParts; + double stockYears = partsPerYear <= 0 ? _plan.PartsDeferYears : mt.Depots.InitialSpareParts / partsPerYear; + if (deferred > (revenue - costs) * Math.Min(_plan.PartsDeferYears, stockYears)) deferred = 0; + } return new Proposal { Candidate = cand, PosA = posA.Value, PosB = posB.Value, ExistingA = existingA, ExistingB = existingB, Polyline = polyline, DepotPos = depotPos, ExistingDepot = existingDepot, - Capital = capital, Revenue = revenue, Costs = costs, Trains = trains, Loco = loco, Car = car, Cars = cars, + Capital = capital, DeferredCapital = deferred, Revenue = revenue, Costs = costs, Trains = trains, Loco = loco, Car = car, Cars = cars, DepotAtB = depotAtB, }; } @@ -1222,7 +1437,7 @@ internal sealed class AiAgent /// Apre i cantieri del progetto: stazioni, deposito, binario e raccordo del deposito. private void Execute(Proposal p, DepotId? supply = null) { - long need = p.Capital + Reserve() - FreeCash(); + long need = p.Capital - p.DeferredCapital + Reserve() - FreeCash(); if (need > 0 && !Borrow(need)) return; var cand = p.Candidate; var stationA = p.ExistingA; diff --git a/src/RailEnterprise.Core/Simulation/Ai/AiState.cs b/src/RailEnterprise.Core/Simulation/Ai/AiState.cs index a38dd9e..3f853da 100644 --- a/src/RailEnterprise.Core/Simulation/Ai/AiState.cs +++ b/src/RailEnterprise.Core/Simulation/Ai/AiState.cs @@ -59,6 +59,14 @@ public sealed class AiState /// Ultimo giorno in cui l'IA ha sciolto uno stallo (uno ogni tanto, non a cascata). public long LastGridlockDay { get; set; } = -1_000_000; + /// + /// Diagnostica del banco di bilanciamento (ADR 0025), né salvata né nell'hash: mesi in cui l'agente non + /// ha aperto reti nuove perché un deposito aspettava la sua linea dei ricambi, e affari di compravendita + /// conclusi (acquisti riusciti). + /// + public long PartsBlockedMonths { get; set; } + public long Trades { get; set; } + /// Quota dei comandi rifiutati sul totale emesso. public double RejectedShare => Issued == 0 ? 0 : (double)Rejected / Issued; } diff --git a/src/RailEnterprise.Core/Simulation/Ai/AiSystem.cs b/src/RailEnterprise.Core/Simulation/Ai/AiSystem.cs index ed4f51a..a01dd9b 100644 --- a/src/RailEnterprise.Core/Simulation/Ai/AiSystem.cs +++ b/src/RailEnterprise.Core/Simulation/Ai/AiSystem.cs @@ -20,6 +20,14 @@ public sealed class AiSystem : ISimSystem if (w.AiPaused) return; EnsureStates(w); int dpm = w.Calendar.DaysPerMonth; + // il bot del giocatore (ADR 0025) prima delle IA, come un giocatore che costruisce dal primo giorno, + // finché la compagnia è in gioco + if (w.PlayerBot is { } bot && !w.Player.Defunct && w.GameOver is null) + { + var agent = new AiAgent(w, ctx, bot.State, _path, bot.Personality); + agent.Daily(); + if (ctx.Day % dpm == bot.State.PlanDay) agent.Monthly(); + } foreach (var s in w.AiStates) { var c = w.Company(s.Company); diff --git a/src/RailEnterprise.Core/Simulation/Ai/PlayerBot.cs b/src/RailEnterprise.Core/Simulation/Ai/PlayerBot.cs new file mode 100644 index 0000000..82fe92c --- /dev/null +++ b/src/RailEnterprise.Core/Simulation/Ai/PlayerBot.cs @@ -0,0 +1,37 @@ +using RailEnterprise.Core.Data; + +namespace RailEnterprise.Core.Simulation.Ai; + +/// +/// «Bot giocatore» del banco di bilanciamento (ADR 0025): guida la compagnia del giocatore con lo stesso +/// agente delle IA (stessi comandi, stesse validazioni) e una personalità della sezione bots di +/// ai.json. Serve solo agli strumenti e ai test: non entra nel salvataggio né nell'hash di stato +/// (gli effetti dei suoi comandi sì, come quelli di un giocatore), e un mondo caricato non ha bot. +/// +public sealed class PlayerBot +{ + private PlayerBot(AiPersonalityDef personality, AiState state) + { + Personality = personality; + State = state; + } + + public AiPersonalityDef Personality { get; } + + /// Stato dell'agente (progetti, comandi emessi e rifiutati), come per le IA. + public AiState State { get; } + + /// Bot con la personalità indicata (id di ai.json → bots) per la compagnia del giocatore. + public static PlayerBot Create(World w, string personalityId) + { + var def = w.Data.Ai.Bots.FirstOrDefault(b => b.Id == personalityId) + ?? throw new ArgumentException($"Bot sconosciuto: {personalityId} (ai.json → bots: {string.Join(", ", w.Data.Ai.Bots.Select(b => b.Id))})"); + // pianifica lo stesso giorno della prima IA ma prima di lei (AiSystem): il giocatore sceglie per primo + var state = new AiState + { + Company = w.Player.Id, + PlanDay = 1 % w.Calendar.DaysPerMonth, + }; + return new PlayerBot(def, state); + } +} diff --git a/src/RailEnterprise.Core/Simulation/World.cs b/src/RailEnterprise.Core/Simulation/World.cs index b3206b3..1c2ad4b 100644 --- a/src/RailEnterprise.Core/Simulation/World.cs +++ b/src/RailEnterprise.Core/Simulation/World.cs @@ -76,6 +76,12 @@ public sealed class World /// Agenti IA sospesi (le compagnie IA esistono ma non agiscono): test e scenari didattici. public bool AiPaused { get; set; } + /// + /// Bot che guida la compagnia del giocatore (banco di bilanciamento, ADR 0025), null di norma. + /// Non è salvato: un mondo caricato riparte senza bot. + /// + public Ai.PlayerBot? PlayerBot { get; set; } + /// Ultimo anno in cui è entrato un nuovo concorrente (12.1). public int LastCompetitorYear { get; set; } = int.MinValue; diff --git a/src/RailEnterprise.Tools/Balance/BalanceBench.cs b/src/RailEnterprise.Tools/Balance/BalanceBench.cs new file mode 100644 index 0000000..7d48324 --- /dev/null +++ b/src/RailEnterprise.Tools/Balance/BalanceBench.cs @@ -0,0 +1,299 @@ +using System.Diagnostics; +using RailEnterprise.Core.Data; +using RailEnterprise.Core.Economy; +using RailEnterprise.Core.Simulation; +using RailEnterprise.Core.Simulation.Ai; +using RailEnterprise.Core.Simulation.Systems; + +namespace RailEnterprise.Tools.Balance; + +/// Matrice del banco di bilanciamento: semi × difficoltà × bot, per un numero di anni (ADR 0025). +public sealed record BalanceOptions +{ + public required IReadOnlyList Seeds { get; init; } + public required IReadOnlyList Difficulties { get; init; } + /// Id dei bot di ai.json → bots; «nessuno» lascia il giocatore passivo. + public required IReadOnlyList Bots { get; init; } + public int Years { get; init; } = 12; + public int SizeKm { get; init; } = 128; + /// Esecuzioni in parallelo (ogni mondo è indipendente: il risultato non cambia). + public int Threads { get; init; } = Environment.ProcessorCount; +} + +/// Una compagnia alla fine di un anno di gioco. +public sealed record CompanyYearRow( + int YearIndex, int Year, string Company, bool IsBot, string Personality, int Tier, long NetWorthCents, string Rating, + long CashCents, long DebtCents, long InterestCents, long TransportRevenueCents, long OperatingProfitCents, + int Trains, int RunningLines, bool Bankrupt, bool Defunct); + +/// Un mese di gioco: prezzi, margini dei trasformatori, coperture, popolazione. +public sealed record MonthRow( + int MonthIndex, double[] PriceRatio, double TransformerMargin, double TransformerNegativeShare, + double SellingTransformerMargin, int SellingTransformers, double Efficiency, double CovInput, double CovWorkers, double CovStaff, + double ServedEfficiency, int ServedIndustries, long Population, double SupersededShare); + +/// Esito di un'esecuzione della matrice. +public sealed class BalanceRun +{ + public required ulong Seed { get; init; } + public required string Difficulty { get; init; } + public required string Bot { get; init; } + public required int Years { get; init; } + public required int StartYear { get; init; } + public List YearRows { get; } = []; + public List Months { get; } = []; + /// Anno di gioco (1 = il primo) in cui il bot ha raggiunto ciascun livello, 0 se mai (indice = livello − 1). + public int[] BotTierYear { get; set; } = []; + public bool BotBankrupt { get; set; } + public bool GameOver { get; set; } + public int AiCompanies { get; set; } + public int AiBankrupt { get; set; } + /// IA con almeno una linea in esercizio alla fine del terzo anno. + public int AiActiveByYear3 { get; set; } + /// IA presenti alla fine del terzo anno (denominatore di O11), −1 se la partita è più corta. + public int AiAtYear3 { get; set; } = -1; + public int BestAiTier { get; set; } + /// Anno di gioco in cui la prima IA ha raggiunto il livello 2, 0 se mai. + public int AiTier2Year { get; set; } + /// Ampliamenti di livello delle industrie e mesi-industria serviti (ritmo di crescita, ADR 0025). + public int LevelUps { get; set; } + public int ServedIndustryMonths { get; set; } + /// Livello più alto raggiunto da un'industria. + public int MaxIndustryLevel { get; set; } + public long PopulationStart { get; set; } + public long PopulationEnd { get; set; } + public long BotCommands { get; set; } + public long BotRejected { get; set; } + public long AiCommands { get; set; } + public long AiRejected { get; set; } + /// Mesi senza reti nuove perché un deposito aspettava la linea dei ricambi (bot, somma delle IA). + public long BotPartsBlockedMonths { get; set; } + public long AiPartsBlockedMonths { get; set; } + /// Affari di compravendita conclusi dal bot e dalle IA. + public long BotTrades { get; set; } + public long AiTrades { get; set; } + public ulong FinalHash { get; set; } + public bool InvariantsOk { get; set; } + /// Durata in millisecondi (non entra nel rapporto deterministico). + public long ElapsedMs { get; set; } +} + +/// +/// Banco di bilanciamento (ADR 0025): per ogni combinazione di seme, difficoltà e bot crea una partita, +/// affida la compagnia del giocatore al bot (lo stesso agente delle IA con una personalità di ai.json → +/// bots) e la fa girare mese per mese, misurando livelli, patrimonio, rating, fallimenti, prezzi rispetto +/// al base, margini dei trasformatori, coperture, città, treni superati e interessi. Le esecuzioni sono +/// indipendenti e si possono fare in parallelo: il rapporto è lo stesso. +/// +public static class BalanceBench +{ + public const string NoBot = "nessuno"; + + public static List Run(GameData data, BalanceOptions o, Action? done = null) + { + foreach (string b in o.Bots) + { + if (b != NoBot && data.Ai.Bots.All(x => x.Id != b)) + throw new ArgumentException($"Bot sconosciuto: {b} (ai.json → bots: {string.Join(", ", data.Ai.Bots.Select(x => x.Id))}, oppure {NoBot})"); + } + foreach (string d in o.Difficulties) data.DifficultyPreset(d); + var plan = new List<(ulong Seed, string Difficulty, string Bot)>(); + foreach (string d in o.Difficulties) + { + foreach (string b in o.Bots) + { + foreach (ulong s in o.Seeds) plan.Add((s, d, b)); + } + } + var runs = new BalanceRun[plan.Count]; + var lockDone = new object(); + Parallel.For(0, plan.Count, new ParallelOptions { MaxDegreeOfParallelism = Math.Max(1, o.Threads) }, i => + { + var (seed, difficulty, bot) = plan[i]; + runs[i] = RunOne(data, seed, difficulty, bot, o.Years, o.SizeKm); + if (done is not null) + { + lock (lockDone) done(runs[i]); + } + }); + return [.. runs]; + } + + /// Una partita: crea il mondo, mette il bot e la fa girare mese per mese. + public static BalanceRun RunOne(GameData data, ulong seed, string difficulty, string bot, int years, int sizeKm) + { + var clock = Stopwatch.StartNew(); + var w = WorldFactory.Create(data, new NewGameSettings { Seed = seed, SizeKm = sizeKm, DifficultyId = difficulty }); + if (bot != NoBot) w.PlayerBot = PlayerBot.Create(w, bot); + var run = new BalanceRun { Seed = seed, Difficulty = difficulty, Bot = bot, Years = years, StartYear = w.Clock.Year }; + run.PopulationStart = w.Towns.Sum(t => (long)t.Population); + int months = w.Calendar.MonthsPerYear; + int dpm = w.Calendar.DaysPerMonth; + var levels = w.Industries.Select(i => i.Level).ToArray(); + // ultimo giorno con vendite di ogni industria (−1 se mai): il margine dei trasformatori «che vendono» + // si misura su chi ha venduto nell'ultimo trimestre (O8) + var lastSale = new List(); + var lastEma = new List(); + double alpha = Ema.Alpha(data.Balance.Industry.MarginWindowDays); + void Day() + { + w.RunDays(1); + long today = w.Clock.Day - 1; + for (int i = 0; i < w.Industries.Count; i++) + { + if (i >= lastSale.Count) + { + lastSale.Add(-1); + lastEma.Add(0); + } + // vendite del giorno ricavate dalla media mobile: RevenueEma = prima + α·(vendite − prima) + double ema = w.Industries[i].RevenueEma; + double sales = lastEma[i] + (ema - lastEma[i]) / alpha; + if (sales >= MinDailySalesCents) lastSale[i] = today; + lastEma[i] = ema; + } + } + int carried = 0; + for (int y = 0; y < years; y++) + { + int year = w.Clock.Year; + for (int m = 0; m < months; m++) + { + for (int d = carried; d < dpm; d++) Day(); + carried = 0; + var month = SampleMonth(w, y * months + m, lastSale); + run.Months.Add(month); + run.ServedIndustryMonths += month.ServedIndustries; + for (int i = 0; i < w.Industries.Count; i++) + { + var ind = w.Industries[i]; + if (i >= levels.Length) continue; // nate durante la partita: contano dal mese dopo + if (ind.Level > levels[i]) run.LevelUps += ind.Level - levels[i]; + levels[i] = ind.Level; + run.MaxIndustryLevel = Math.Max(run.MaxIndustryLevel, ind.Level); + } + if (levels.Length < w.Industries.Count) levels = [.. levels, .. w.Industries.Skip(levels.Length).Select(i => i.Level)]; + w.Events.Drain(); + } + // il bilancio dell'anno si chiude al primo tick dell'anno dopo, che registra ancora rate e interessi di + // dicembre: si campiona dopo quel giorno, dall'anno chiuso (LastYearEntries) + Day(); + carried = 1; + SampleYear(w, run, y + 1, year); + if (y + 1 == 3) + { + run.AiActiveByYear3 = w.AiStates.Count(s => !w.Company(s.Company).Defunct && s.Projects.Any(p => p.Stage == AiProjectStage.Running)); + run.AiAtYear3 = w.AiStates.Count; + } + } + var player = w.Player; + run.BotTierYear = new int[data.Tiers.Tiers.Count]; + for (int t = 1; t < run.BotTierYear.Length; t++) + { + long day = player.TierReachedDay[t]; + run.BotTierYear[t] = day < 0 ? 0 : (int)(day / w.Calendar.DaysPerYear) + 1; + } + run.BotTierYear[0] = 1; + run.BotBankrupt = player.Bankrupt; + run.GameOver = w.GameOver is not null; + var ais = w.Companies.Where(c => !c.IsPlayer).ToList(); + run.AiCompanies = ais.Count; + run.AiBankrupt = ais.Count(c => c.Bankrupt); + run.BestAiTier = ais.Count == 0 ? 0 : ais.Max(c => c.Tier); + long firstAi2 = ais.Select(c => c.TierReachedDay[1]).Where(d => d >= 0).DefaultIfEmpty(-1).Min(); + run.AiTier2Year = firstAi2 < 0 ? 0 : (int)(firstAi2 / w.Calendar.DaysPerYear) + 1; + run.PopulationEnd = w.Towns.Sum(t => (long)t.Population); + if (w.PlayerBot is { } pb) + { + run.BotCommands = pb.State.Issued; + run.BotRejected = pb.State.Rejected; + run.BotPartsBlockedMonths = pb.State.PartsBlockedMonths; + run.BotTrades = pb.State.Trades; + } + run.AiCommands = w.AiStates.Sum(s => s.Issued); + run.AiRejected = w.AiStates.Sum(s => s.Rejected); + run.AiPartsBlockedMonths = w.AiStates.Sum(s => s.PartsBlockedMonths); + run.AiTrades = w.AiStates.Sum(s => s.Trades); + run.FinalHash = w.LastStateHash; + run.InvariantsOk = w.MoneyBalanceSum() == 0 && Enumerable.Range(0, data.GoodCount).All(g => w.TotalStock(g) == w.Goods.ExpectedStock(g)); + run.ElapsedMs = clock.ElapsedMilliseconds; + return run; + } + + /// Vendite giornaliere minime (centesimi) perché un giorno conti come giorno con vendite (soglia del banco). + public const double MinDailySalesCents = 1; + + private static MonthRow SampleMonth(World w, int monthIndex, List lastSale) + { + var data = w.Data; + int year = w.Clock.Year; + int dpm = w.Calendar.DaysPerMonth; + var ratio = new double[data.GoodCount]; + for (int g = 0; g < data.GoodCount; g++) + { + var def = data.Goods[g]; + ratio[g] = def.Era > year ? double.NaN : w.Market.PriceHistory[g].AverageOfLast(dpm) / def.BasePrice; + } + long day = w.Clock.Day; + int window = data.Balance.Growth.QuarterDays; + double margin = 0, servedMargin = 0, eff = 0, ci = 0, cw = 0, cs = 0, servedEff = 0; + int transformers = 0, negative = 0, served = 0, open = 0, servedAll = 0; + foreach (var ind in w.Industries) + { + if (ind.Closed || ind.Level <= 0) continue; + long sold = ind.Id.Value < lastSale.Count ? lastSale[ind.Id.Value] : -1; + open++; + eff += ind.Efficiency; + ci += ind.CovInput; + cw += ind.CovWorkers; + cs += ind.CovStaff; + bool isServed = ind.ServedWithin(day, window); + if (isServed) + { + servedAll++; + servedEff += ind.Efficiency; + } + if (ind.Def.Kind == IndustryKind.Primary) continue; + transformers++; + margin += ind.Margin; + if (ind.Margin < 0) negative++; + // trasformatori che vendono (ritiri dei vettori o trasporto locale) nell'ultimo trimestre: senza vendite + // il margine tende a −1 per costruzione, qualunque siano i prezzi; RevenueEma > 0 non basta (una media + // mobile esponenziale non torna più a zero dopo la prima vendita) + if (sold >= 0 && day - sold <= window) + { + served++; + servedMargin += ind.Margin; + } + } + int vehicles = 0, superseded = 0; + foreach (var v in w.Vehicles) + { + if (v.Sold) continue; + vehicles++; + if (Obsolescence.IsSuperseded(v.Def, year)) superseded++; + } + return new MonthRow( + monthIndex, ratio, + transformers == 0 ? 0 : margin / transformers, transformers == 0 ? 0 : (double)negative / transformers, + served == 0 ? double.NaN : servedMargin / served, served, + open == 0 ? 0 : eff / open, open == 0 ? 0 : ci / open, open == 0 ? 0 : cw / open, open == 0 ? 0 : cs / open, + servedAll == 0 ? double.NaN : servedEff / servedAll, servedAll, + w.Towns.Sum(t => (long)t.Population), vehicles == 0 ? 0 : (double)superseded / vehicles); + } + + private static void SampleYear(World w, BalanceRun run, int yearIndex, int year) + { + foreach (var c in w.Companies) + { + var state = c.IsPlayer ? w.PlayerBot?.State : w.AiStates.FirstOrDefault(s => s.Company == c.Id); + int lines = state?.Projects.Count(p => p.Stage == AiProjectStage.Running) ?? 0; + int trains = w.Trains.Count(t => !t.Removed && t.Owner == c.Id); + string personality = c.IsPlayer ? w.PlayerBot?.Personality.Id ?? NoBot : c.AiPersonality ?? ""; + run.YearRows.Add(new CompanyYearRow( + yearIndex, year, c.Name, c.IsPlayer, personality, c.Tier, c.NetWorth.Cents, c.Rating.ToString(), + c.Cash.Cents, c.Debt.Cents, -c.LastYearEntries[(int)LedgerEntry.Interest], Company.TransportRevenue(c.LastYearEntries), + Company.OperatingProfit(c.LastYearEntries), trains, lines, c.Bankrupt, c.Defunct)); + } + } +} diff --git a/src/RailEnterprise.Tools/Balance/BalanceReport.cs b/src/RailEnterprise.Tools/Balance/BalanceReport.cs new file mode 100644 index 0000000..3c9fea7 --- /dev/null +++ b/src/RailEnterprise.Tools/Balance/BalanceReport.cs @@ -0,0 +1,433 @@ +using System.Globalization; +using System.Text; +using RailEnterprise.Core.Data; + +namespace RailEnterprise.Tools.Balance; + +/// Esito di un obiettivo dell'ADR 0025 sulla matrice eseguita. +public sealed record GoalResult(string Id, string Text, string Measured, bool? Met); + +/// +/// Rapporto del banco di bilanciamento (ADR 0025): testo riassuntivo per difficoltà e bot, obiettivi +/// con l'esito e CSV di dettaglio (separatore «;», decimali con la virgola, come simulate). Il testo e i +/// CSV dipendono solo dalle esecuzioni (non dai tempi): stesso seme, stesso rapporto. +/// +public static class BalanceReport +{ + private static readonly CultureInfo It = CultureInfo.InvariantCulture; + + // Obiettivi dell'ADR 0025 (soglie del banco, non della simulazione). + public const string NormalDifficulty = "imprenditore"; + public const string EasyDifficulty = "apprendista"; + public const string CompetentBot = "bot_competent"; + public const string PrudentBot = "bot_prudent"; + public const int Tier2FromYear = 3, Tier2ToYear = 6; + public const int EasyTier2ByYear = 5; + public const double PriceLow = 0.7, PriceHigh = 1.6; + public const double PriceMonthsInBand = 0.95; + public const double TransformerPositiveMonths = 0.8; + public const double ServedEfficiencyMin = 0.6; + public const double PopulationGrowthMin = -0.005; + public const double AiActiveShareMin = 0.5; + public const double InterestShareMax = 0.2; + public const double RejectedShareMax = 0.05; + + /// Mediana degli anni (0 = mai, contato come oltre la fine) come testo. + /// Con un numero pari di semi la mediana sono i due valori centrali («4–8»). + private static string MedianYear(IEnumerable years, int horizon) + { + var (lo, hi) = MedianYearValue(years); + if (lo == int.MinValue) return "–"; + string Y(int y) => y == int.MaxValue || y > horizon ? "mai" : y.ToString(It); + return lo == hi ? Y(lo) : $"{Y(lo)}–{Y(hi)}"; + } + + /// + /// I due valori centrali degli anni (uguali con un numero dispari di semi), con «mai» oltre ogni soglia: + /// un obiettivo sulla mediana vale solo se vale per entrambi, così un obiettivo mancato non passa per caso. + /// + private static (int Lo, int Hi) MedianYearValue(IEnumerable years) + { + var list = years.Select(y => y == 0 ? int.MaxValue : y).OrderBy(y => y).ToList(); + if (list.Count == 0) return (int.MinValue, int.MinValue); + return (list[(list.Count - 1) / 2], list[list.Count / 2]); + } + + /// Quanti anni stanno nella fascia [from, to], come «3 su 6». + private static string InBand(IEnumerable years, int from, int to) + { + var list = years.ToList(); + return $"{list.Count(y => y >= from && y <= to)} su {list.Count} nella fascia"; + } + + private static long Median(IEnumerable values) + { + var list = values.OrderBy(v => v).ToList(); + return list.Count == 0 ? 0 : list[(list.Count - 1) / 2]; + } + + public static string Dec(double v, string format = "0.###") => double.IsNaN(v) ? "" : v.ToString(format, It).Replace('.', ','); + private static string Pct(double v) => double.IsNaN(v) ? "–" : (v * 100).ToString("0.0", It).Replace('.', ',') + " %"; + private static string Lire(long cents) => Core.Common.Money.FromCentsRounded(cents).ToString(); + + /// Obiettivi dell'ADR 0025 misurati sulle esecuzioni (null = combinazione non eseguita). + public static List Goals(GameData data, List runs) + { + var goals = new List(); + int horizon = runs.Count == 0 ? 0 : runs.Max(r => r.Years); + List Of(string difficulty, string bot) => runs.Where(r => r.Difficulty == difficulty && r.Bot == bot).ToList(); + + var normal = Of(NormalDifficulty, CompetentBot); + if (normal.Count > 0) + { + var years = normal.Select(r => r.BotTierYear[1]).ToList(); + var (lo, hi) = MedianYearValue(years); + goals.Add(new GoalResult("O1", $"bot competente in «Imprenditore»: livello 2 tra il {Tier2FromYear}° e il {Tier2ToYear}° anno (mediana)", + $"mediana {MedianYear(years, horizon)} (anni: {string.Join(", ", years.Select(y => y == 0 ? "mai" : y.ToString(It)))}; {InBand(years, Tier2FromYear, Tier2ToYear)})", + lo >= Tier2FromYear && hi <= Tier2ToYear)); + } + else goals.Add(new GoalResult("O1", "bot competente in «Imprenditore»: livello 2 tra il 3° e il 6° anno", "non eseguito", null)); + + var easy = Of(EasyDifficulty, CompetentBot); + if (easy.Count > 0) + { + var years = easy.Select(r => r.BotTierYear[1]).ToList(); + var (_, hi) = MedianYearValue(years); + goals.Add(new GoalResult("O2", $"bot competente in «Apprendista»: livello 2 entro il {EasyTier2ByYear}° anno (mediana)", + $"mediana {MedianYear(years, horizon)} (anni: {string.Join(", ", years.Select(y => y == 0 ? "mai" : y.ToString(It)))}; {InBand(years, 1, EasyTier2ByYear)})", hi <= EasyTier2ByYear)); + } + else goals.Add(new GoalResult("O2", "bot competente in «Apprendista»: livello 2 entro il 5° anno", "non eseguito", null)); + + // la difficoltà conta: patrimonio finale mediano del bot competente non crescente con la difficoltà. + // Si contano solo le partite in cui il bot ha giocato (almeno una linea in esercizio): un bot fermo + // chiude con il capitale iniziale, che decresce con la difficoltà, e l'obiettivo passerebbe da solo. + var order = data.Difficulty.Presets.Select(p => p.Id).Where(d => Of(d, CompetentBot).Count > 0).ToList(); + if (order.Count >= 2) + { + var idle = order.Where(d => !Of(d, CompetentBot).Any(Played)).ToList(); + var worth = order.Select(d => Median(Of(d, CompetentBot).Where(Played).Select(r => FinalBot(r)?.NetWorthCents ?? 0))).ToList(); + string measured = string.Join(" ≥ ", order.Zip(worth, (d, v) => idle.Contains(d) ? $"{d} senza partite giocate" : $"{d} {Lire(v)}")); + if (idle.Count > 0) + { + goals.Add(new GoalResult("O3", "bot competente: patrimonio finale mediano non crescente con la difficoltà", + $"non valutabile: il bot non costruisce in {string.Join(", ", idle)} ({measured})", null)); + } + else + { + bool ok = true; + for (int i = 1; i < worth.Count; i++) ok &= worth[i] <= worth[i - 1]; + goals.Add(new GoalResult("O3", "bot competente: patrimonio finale mediano non crescente con la difficoltà", measured, ok)); + } + } + else goals.Add(new GoalResult("O3", "patrimonio decrescente con la difficoltà", "servono almeno due difficoltà", null)); + + goals.Add(Bankruptcies("O4", "nessun fallimento del bot prudente in «Apprendista» e «Imprenditore»", + runs.Where(r => r.Bot == PrudentBot && (r.Difficulty == EasyDifficulty || r.Difficulty == NormalDifficulty)).ToList())); + goals.Add(Bankruptcies("O5", "nessun fallimento del bot competente in «Apprendista» e «Imprenditore»", + runs.Where(r => r.Bot == CompetentBot && (r.Difficulty == EasyDifficulty || r.Difficulty == NormalDifficulty)).ToList())); + + // obiettivi del mondo (O6–O11): una partita per seme e difficoltà, perché le partite dei due bot con + // lo stesso seme condividono mappa e IA e, se il bot non gioca, sono quasi lo stesso mondo + var world = WorldRuns(runs); + string n = $"{world.Count} partite distinte"; + + // prezzi: media di ogni bene in ogni partita (O6) e mesi-bene nella fascia della difficoltà (O7) + int goods = data.GoodCount; + double worstLow = double.MaxValue, worstHigh = double.MinValue, pooledLow = double.MaxValue, pooledHigh = double.MinValue; + string lowAt = "", highAt = "", pooledLowGood = "", pooledHighGood = ""; + int outOfBand = 0, pairs = 0; + for (int g = 0; g < goods; g++) + { + var all = new List(); + foreach (var r in world) + { + var v = r.Months.Select(m => m.PriceRatio[g]).Where(x => !double.IsNaN(x)).ToList(); + if (v.Count == 0) continue; + all.AddRange(v); + double mean = v.Average(); + pairs++; + if (mean < PriceLow || mean > PriceHigh) outOfBand++; + if (mean < worstLow) (worstLow, lowAt) = (mean, $"{data.Goods[g].Id} (seme {r.Seed}, {r.Difficulty})"); + if (mean > worstHigh) (worstHigh, highAt) = (mean, $"{data.Goods[g].Id} (seme {r.Seed}, {r.Difficulty})"); + } + if (all.Count == 0) continue; + double pooled = all.Average(); + if (pooled < pooledLow) (pooledLow, pooledLowGood) = (pooled, data.Goods[g].Id); + if (pooled > pooledHigh) (pooledHigh, pooledHighGood) = (pooled, data.Goods[g].Id); + } + if (pairs > 0) + { + goals.Add(new GoalResult("O6", $"media di ogni bene in ogni partita entro {Dec(PriceLow)}–{Dec(PriceHigh)} volte il base", + $"peggiori: più bassa {lowAt} {Dec(worstLow, "0.00")}, più alta {highAt} {Dec(worstHigh, "0.00")}; {outOfBand} su {pairs} medie partita-bene fuori; " + + $"sull'insieme delle partite {pooledLowGood} {Dec(pooledLow, "0.00")} – {pooledHighGood} {Dec(pooledHigh, "0.00")} ({n})", + outOfBand == 0)); + int inBand = 0, total = 0; + bool everyDifficulty = true; + var perDifficulty = new List(); + foreach (var preset in data.Difficulty.Presets) + { + var set = world.Where(r => r.Difficulty == preset.Id).ToList(); + if (set.Count == 0) continue; + var (low, high) = PriceBand(preset.MarketVolatilityMultiplier); + int dIn = 0, dTotal = 0; + foreach (var r in set) + { + foreach (var m in r.Months) + { + foreach (double v in m.PriceRatio) + { + if (double.IsNaN(v)) continue; + dTotal++; + if (v >= low && v <= high) dIn++; + } + } + } + inBand += dIn; + total += dTotal; + if (dTotal > 0 && (double)dIn / dTotal < PriceMonthsInBand) everyDifficulty = false; + perDifficulty.Add($"{preset.Id} {Pct(dTotal == 0 ? double.NaN : (double)dIn / dTotal)} in {Dec(low, "0.00")}–{Dec(high, "0.00")}"); + } + double share = total == 0 ? 0 : (double)inBand / total; + goals.Add(new GoalResult("O7", $"in ogni difficoltà almeno il {Dec(PriceMonthsInBand * 100)} % dei mesi-bene entro {Dec(PriceLow)}–{Dec(PriceHigh)} volte il base (fascia allargata dalla volatilità della difficoltà)", + $"{string.Join("; ", perDifficulty)}; tutte insieme {Pct(share)}", everyDifficulty)); + } + + // margini dei trasformatori che hanno venduto nell'ultimo trimestre (gli altri hanno margine −1 per costruzione) + var served = world.SelectMany(r => r.Months).Where(m => !double.IsNaN(m.SellingTransformerMargin)).ToList(); + if (served.Count > 0) + { + double share = (double)served.Count(m => m.SellingTransformerMargin > 0) / served.Count; + goals.Add(new GoalResult("O8", $"margine medio dei trasformatori che vendono positivo in almeno il {Dec(TransformerPositiveMonths * 100)} % dei mesi", + $"{Pct(share)} (margine medio {Dec(served.Average(m => m.SellingTransformerMargin), "0.000")}, {Dec(served.Average(m => m.SellingTransformers), "0.0")} trasformatori che vendono al mese)", share >= TransformerPositiveMonths)); + } + else goals.Add(new GoalResult("O8", "margine dei trasformatori che vendono positivo", "nessun trasformatore vende", null)); + + var servedEff = world.SelectMany(r => r.Months.Skip(r.Months.Count / 2)).Where(m => !double.IsNaN(m.ServedEfficiency)).ToList(); + if (servedEff.Count > 0) + { + double eff = servedEff.Average(m => m.ServedEfficiency); + goals.Add(new GoalResult("O9", $"efficienza media delle industrie servite almeno {Dec(ServedEfficiencyMin)} (seconda metà)", Dec(eff, "0.000"), eff >= ServedEfficiencyMin)); + } + + var normalAll = world.Where(r => r.Difficulty == NormalDifficulty && r.Bot != BalanceBench.NoBot).ToList(); + if (normalAll.Count > 0) + { + double growth = normalAll.Average(r => AnnualGrowth(r)); + goals.Add(new GoalResult("O10", $"popolazione in «Imprenditore» (con bot): crescita media annua almeno {Pct(PopulationGrowthMin)}", Pct(growth), growth >= PopulationGrowthMin)); + } + + // IA attive entro il 3° anno su quelle presenti allora (i concorrenti nati dopo non contano) + var year3 = world.Where(r => r.AiAtYear3 >= 0).ToList(); + int ais = year3.Sum(r => r.AiAtYear3), active = year3.Sum(r => r.AiActiveByYear3); + if (year3.Count == 0) goals.Add(new GoalResult("O11", "IA con una linea in esercizio entro il 3° anno", "non eseguito (partite più corte di 3 anni)", null)); + else if (ais > 0) + { + double share = (double)active / ais; + goals.Add(new GoalResult("O11", $"almeno il {Dec(AiActiveShareMin * 100)} % delle IA con una linea in esercizio entro il 3° anno", $"{active} su {ais} ({Pct(share)})", share >= AiActiveShareMin)); + } + + if (normal.Count > 0) + { + long interest = normal.Sum(r => r.YearRows.Where(y => y.IsBot).Sum(y => y.InterestCents)); + long revenue = normal.Sum(r => r.YearRows.Where(y => y.IsBot).Sum(y => y.TransportRevenueCents)); + double share = revenue <= 0 ? double.PositiveInfinity : (double)interest / revenue; + goals.Add(new GoalResult("O12", $"bot competente in «Imprenditore»: interessi entro il {Dec(InterestShareMax * 100)} % dei ricavi dei trasporti", + $"{Lire(interest)} su {Lire(revenue)} ({(double.IsInfinity(share) ? "senza ricavi" : Pct(share))})", share <= InterestShareMax)); + } + + long cmds = runs.Sum(r => r.BotCommands + r.AiCommands), rej = runs.Sum(r => r.BotRejected + r.AiRejected); + if (cmds > 0) + { + double share = (double)rej / cmds; + goals.Add(new GoalResult("O13", $"comandi rifiutati di bot e IA al massimo il {Dec(RejectedShareMax * 100)} % (14.5)", $"{rej} su {cmds} ({Pct(share)})", share <= RejectedShareMax)); + } + bool inv = runs.All(r => r.InvariantsOk); + goals.Add(new GoalResult("O14", "invarianti di denaro e merci in ogni esecuzione", inv ? "rispettati" : "ROTTI", inv)); + return goals; + } + + private static CompanyYearRow? FinalBot(BalanceRun r) => r.YearRows.LastOrDefault(y => y.IsBot); + + /// Il bot ha giocato: almeno una linea in esercizio alla fine di un anno (gli obiettivi O3–O5 contano solo queste partite). + public static bool Played(BalanceRun r) => r.YearRows.Any(y => y.IsBot && y.RunningLines > 0); + + /// Fallimenti del bot sulle partite giocate; quelle senza linee si dichiarano e non contano. + private static GoalResult Bankruptcies(string id, string text, List set) + { + if (set.Count == 0) return new GoalResult(id, text, "non eseguito", null); + var played = set.Where(Played).ToList(); + int idle = set.Count - played.Count; + string idleText = idle == 0 ? "" : $" ({idle} senza linee, non contate)"; + if (played.Count == 0) return new GoalResult(id, text, $"non valutabile: il bot non costruisce in nessuna delle {set.Count} partite", null); + int failed = played.Count(r => r.BotBankrupt || r.GameOver); + return new GoalResult(id, text, $"{failed} su {played.Count}{idleText}", failed == 0); + } + + /// + /// Una partita per seme e difficoltà per gli obiettivi del mondo: quella del bot competente se c'è, + /// altrimenti la prima del piano. + /// + public static List WorldRuns(List runs) + { + var list = new List(); + foreach (var r in runs) + { + int k = list.FindIndex(x => x.Seed == r.Seed && x.Difficulty == r.Difficulty); + if (k < 0) list.Add(r); + else if (r.Bot == CompetentBot && list[k].Bot != CompetentBot) list[k] = r; + } + return list; + } + + /// + /// Fascia dei prezzi di O7 per la difficoltà: 0,7–1,6 volte il base, allargata in proporzione alla + /// volatilità del mercato quando la difficoltà la moltiplica (sezione 7: A e shock × 1,3 o × 1,6). + /// + public static (double Low, double High) PriceBand(double volatility) + { + double v = Math.Max(1, volatility); + return (1 - (1 - PriceLow) * v, 1 + (PriceHigh - 1) * v); + } + + /// Crescita media annua composta della popolazione complessiva. + public static double AnnualGrowth(BalanceRun r) => + r.PopulationStart <= 0 || r.Years <= 0 ? 0 : Core.Common.DMath.Pow((double)r.PopulationEnd / r.PopulationStart, 1.0 / r.Years) - 1; + + /// Testo del rapporto (deterministico: non contiene tempi). + public static string Text(GameData data, BalanceOptions o, List runs) + { + var sb = new StringBuilder(); + sb.AppendLine("Banco di bilanciamento (ADR 0025)"); + sb.AppendLine($"semi {string.Join(", ", o.Seeds)}; difficoltà {string.Join(", ", o.Difficulties)}; bot {string.Join(", ", o.Bots)}; {o.Years} anni su {o.SizeKm} km; {runs.Count} esecuzioni"); + sb.AppendLine(); + sb.AppendLine("Obiettivi"); + var goals = Goals(data, runs); + foreach (var g in goals) + sb.AppendLine($" {(g.Met is null ? "–" : g.Met.Value ? "sì" : "NO")} {g.Id} {g.Text}: {g.Measured}"); + sb.AppendLine($" raggiunti {goals.Count(g => g.Met == true)} su {goals.Count(g => g.Met is not null)}"); + int horizon = o.Years; + foreach (string d in o.Difficulties) + { + foreach (string b in o.Bots) + { + var set = runs.Where(r => r.Difficulty == d && r.Bot == b).ToList(); + if (set.Count == 0) continue; + sb.AppendLine(); + sb.AppendLine($"[{d} / {b}] {set.Count} semi"); + if (b != BalanceBench.NoBot) + { + for (int t = 2; t <= data.Tiers.Tiers.Count; t++) + { + var years = set.Select(r => r.BotTierYear[t - 1]).ToList(); + if (years.All(y => y == 0)) continue; + sb.AppendLine($" bot livello {t}: anno mediano {MedianYear(years, horizon)} (semi: {string.Join(", ", years.Select(y => y == 0 ? "mai" : y.ToString(It)))})"); + } + var finals = set.Select(FinalBot).Where(x => x is not null).Select(x => x!).ToList(); + sb.AppendLine($" bot alla fine: livello {string.Join("/", finals.Select(f => f.Tier))}, patrimonio mediano {Lire(Median(finals.Select(f => f.NetWorthCents)))}, rating {string.Join("/", finals.Select(f => f.Rating))}, treni {string.Join("/", finals.Select(f => f.Trains))}"); + sb.AppendLine($" bot fallito: {set.Count(r => r.BotBankrupt)}, fine partita: {set.Count(r => r.GameOver)}; interessi pagati (mediana del totale) {Lire(Median(set.Select(r => r.YearRows.Where(y => y.IsBot).Sum(y => y.InterestCents))))}"); + sb.AppendLine($" livello per anno (prima esecuzione): {string.Join(" ", set[0].YearRows.Where(y => y.IsBot).Select(y => y.Tier))}"); + sb.AppendLine($" bot con almeno una linea: {set.Count(Played)} su {set.Count}; mesi senza reti nuove in attesa dei ricambi {string.Join("/", set.Select(r => r.BotPartsBlockedMonths))}; affari di compravendita {string.Join("/", set.Select(r => r.BotTrades))}"); + } + sb.AppendLine($" IA: {set.Sum(r => r.AiCompanies)} compagnie, fallite {set.Sum(r => r.AiBankrupt)}, attive al 3° anno {set.Sum(r => r.AiActiveByYear3)} su {set.Sum(r => Math.Max(0, r.AiAtYear3))}, mesi senza reti nuove in attesa dei ricambi {set.Sum(r => r.AiPartsBlockedMonths)}, affari {set.Sum(r => r.AiTrades)}, livello massimo {string.Join("/", set.Select(r => r.BestAiTier))}, primo livello 2 di un'IA all'anno {MedianYear(set.Select(r => r.AiTier2Year), horizon)} (mediana)"); + var months = set.SelectMany(r => r.Months).ToList(); + var served = months.Where(m => !double.IsNaN(m.SellingTransformerMargin)).ToList(); + sb.AppendLine($" trasformatori: margine medio {Dec(months.Average(m => m.TransformerMargin), "0.000")} (quota in perdita {Pct(months.Average(m => m.TransformerNegativeShare))}); che vendono {Dec(served.Count == 0 ? double.NaN : served.Average(m => m.SellingTransformerMargin), "0.000")}, mesi positivi {Pct(served.Count == 0 ? double.NaN : (double)served.Count(m => m.SellingTransformerMargin > 0) / served.Count)}"); + var se = months.Where(m => !double.IsNaN(m.ServedEfficiency)).ToList(); + sb.AppendLine($" coperture medie: input {Dec(months.Average(m => m.CovInput), "0.00")}, lavoratori {Dec(months.Average(m => m.CovWorkers), "0.00")}, personale {Dec(months.Average(m => m.CovStaff), "0.00")}; efficienza {Dec(months.Average(m => m.Efficiency), "0.00")}, servite {Dec(se.Count == 0 ? double.NaN : se.Average(m => m.ServedEfficiency), "0.00")}"); + int servedMonths = set.Sum(r => r.ServedIndustryMonths); + sb.AppendLine($" industrie: ampliamenti {set.Sum(r => r.LevelUps)}, per industria servita all'anno {Dec(servedMonths == 0 ? double.NaN : set.Sum(r => r.LevelUps) * 12.0 / servedMonths, "0.00")}, livello massimo {string.Join("/", set.Select(r => r.MaxIndustryLevel))}"); + sb.AppendLine($" città: crescita media annua {Pct(set.Average(AnnualGrowth))}; veicoli superati alla fine {Pct(set.Average(r => r.Months[^1].SupersededShare))}"); + var prices = new List(); + for (int g = 0; g < data.GoodCount; g++) + { + var v = months.Select(m => m.PriceRatio[g]).Where(x => !double.IsNaN(x)).ToList(); + if (v.Count == 0) continue; + prices.Add($"{data.Goods[g].Id} {Dec(v.Min(), "0.00")}/{Dec(v.Average(), "0.00")}/{Dec(v.Max(), "0.00")}"); + } + sb.AppendLine($" prezzi / base (min/medio/max): {string.Join("; ", prices)}"); + } + } + return sb.ToString(); + } + + /// Scrive rapporto.txt e i CSV nella cartella indicata. + public static void Write(string dir, GameData data, BalanceOptions o, List runs) + { + Directory.CreateDirectory(dir); + var utf8 = new UTF8Encoding(encoderShouldEmitUTF8Identifier: true); + File.WriteAllText(Path.Combine(dir, "rapporto.txt"), Text(data, o, runs), utf8); + File.WriteAllText(Path.Combine(dir, "anni.csv"), YearsCsv(runs), utf8); + File.WriteAllText(Path.Combine(dir, "mesi.csv"), MonthsCsv(data, runs), utf8); + File.WriteAllText(Path.Combine(dir, "prezzi.csv"), PricesCsv(data, runs), utf8); + File.WriteAllText(Path.Combine(dir, "esecuzioni.csv"), RunsCsv(data, runs), utf8); + } + + public static string YearsCsv(List runs) + { + var sb = new StringBuilder("seme;difficoltà;bot;anno di gioco;anno;compagnia;bot giocatore;personalità;livello;patrimonio;rating;cassa;debito;interessi;ricavi trasporti;utile operativo;treni;linee;fallita;fuori gioco\n"); + foreach (var r in runs) + { + foreach (var y in r.YearRows) + { + sb.AppendLine(string.Join(';', r.Seed.ToString(It), r.Difficulty, r.Bot, y.YearIndex.ToString(It), y.Year.ToString(It), y.Company, + y.IsBot ? "sì" : "no", y.Personality, y.Tier.ToString(It), Dec(y.NetWorthCents / 100.0, "0.00"), y.Rating, + Dec(y.CashCents / 100.0, "0.00"), Dec(y.DebtCents / 100.0, "0.00"), Dec(y.InterestCents / 100.0, "0.00"), + Dec(y.TransportRevenueCents / 100.0, "0.00"), Dec(y.OperatingProfitCents / 100.0, "0.00"), + y.Trains.ToString(It), y.RunningLines.ToString(It), y.Bankrupt ? "sì" : "no", y.Defunct ? "sì" : "no")); + } + } + return sb.ToString(); + } + + public static string MonthsCsv(GameData data, List runs) + { + var sb = new StringBuilder("seme;difficoltà;bot;mese;margine trasformatori;quota in perdita;margine trasformatori che vendono;trasformatori che vendono;efficienza;copertura input;copertura lavoratori;copertura personale;efficienza servite;industrie servite;popolazione;quota superati;"); + sb.AppendLine(string.Join(';', data.Goods.Select(g => "prezzo/base " + g.Id))); + foreach (var r in runs) + { + foreach (var m in r.Months) + { + sb.Append(string.Join(';', r.Seed.ToString(It), r.Difficulty, r.Bot, (m.MonthIndex + 1).ToString(It), Dec(m.TransformerMargin), Dec(m.TransformerNegativeShare), + Dec(m.SellingTransformerMargin), m.SellingTransformers.ToString(It), Dec(m.Efficiency), Dec(m.CovInput), Dec(m.CovWorkers), Dec(m.CovStaff), + Dec(m.ServedEfficiency), m.ServedIndustries.ToString(It), m.Population.ToString(It), Dec(m.SupersededShare))); + sb.Append(';'); + sb.AppendLine(string.Join(';', m.PriceRatio.Select(v => Dec(v)))); + } + } + return sb.ToString(); + } + + public static string PricesCsv(GameData data, List runs) + { + var sb = new StringBuilder("seme;difficoltà;bot;bene;minimo/base;medio/base;massimo/base;mesi fuori 0,7–1,6\n"); + foreach (var r in runs) + { + for (int g = 0; g < data.GoodCount; g++) + { + var v = r.Months.Select(m => m.PriceRatio[g]).Where(x => !double.IsNaN(x)).ToList(); + if (v.Count == 0) continue; + sb.AppendLine(string.Join(';', r.Seed.ToString(It), r.Difficulty, r.Bot, data.Goods[g].Id, Dec(v.Min()), Dec(v.Average()), Dec(v.Max()), + v.Count(x => x < PriceLow || x > PriceHigh).ToString(It))); + } + } + return sb.ToString(); + } + + public static string RunsCsv(GameData data, List runs) + { + var sb = new StringBuilder("seme;difficoltà;bot;anni;"); + sb.Append(string.Join(';', Enumerable.Range(2, data.Tiers.Tiers.Count - 1).Select(t => $"anno livello {t}"))); + sb.AppendLine(";bot fallito;fine partita;IA;IA fallite;IA attive al 3° anno;livello massimo IA;anno livello 2 IA;ampliamenti industrie;mesi-industria serviti;livello massimo industrie;popolazione iniziale;popolazione finale;comandi bot;rifiutati bot;comandi IA;rifiutati IA;IA al 3° anno;mesi bloccati ricambi bot;mesi bloccati ricambi IA;affari bot;affari IA;invarianti;hash finale"); + foreach (var r in runs) + { + sb.Append(string.Join(';', r.Seed.ToString(It), r.Difficulty, r.Bot, r.Years.ToString(It))); + sb.Append(';'); + sb.Append(string.Join(';', r.BotTierYear.Skip(1).Select(y => y.ToString(It)))); + sb.AppendLine(";" + string.Join(';', r.BotBankrupt ? "sì" : "no", r.GameOver ? "sì" : "no", r.AiCompanies.ToString(It), r.AiBankrupt.ToString(It), + r.AiActiveByYear3.ToString(It), r.BestAiTier.ToString(It), r.AiTier2Year.ToString(It), r.LevelUps.ToString(It), r.ServedIndustryMonths.ToString(It), r.MaxIndustryLevel.ToString(It), r.PopulationStart.ToString(It), r.PopulationEnd.ToString(It), + r.BotCommands.ToString(It), r.BotRejected.ToString(It), r.AiCommands.ToString(It), r.AiRejected.ToString(It), + r.AiAtYear3.ToString(It), r.BotPartsBlockedMonths.ToString(It), r.AiPartsBlockedMonths.ToString(It), r.BotTrades.ToString(It), r.AiTrades.ToString(It), r.InvariantsOk ? "ok" : "ROTTI", r.FinalHash.ToString("x16", It))); + } + return sb.ToString(); + } +} diff --git a/src/RailEnterprise.Tools/Commands/BalanceCommand.cs b/src/RailEnterprise.Tools/Commands/BalanceCommand.cs new file mode 100644 index 0000000..9bad3b5 --- /dev/null +++ b/src/RailEnterprise.Tools/Commands/BalanceCommand.cs @@ -0,0 +1,58 @@ +using System.Diagnostics; +using System.Globalization; +using RailEnterprise.Core.Data; +using RailEnterprise.Tools.Balance; + +namespace RailEnterprise.Tools.Commands; + +/// +/// balance: banco di bilanciamento con i bot giocatore (ADR 0025). Fa giocare il bot e le IA su +/// semi × difficoltà × bot per N anni e scrive in una cartella il rapporto con gli obiettivi +/// (rapporto.txt) e i CSV di dettaglio (anni, mesi, prezzi, esecuzioni); i tempi vanno in tempi.txt. +/// +public sealed class BalanceCommand : IToolCommand +{ + public string Name => "balance"; + + public string Usage => "balance [--seeds 1,2,3] [--difficulties apprendista,imprenditore,magnate,ferro_e_sangue] [--bots bot_competent,bot_prudent|nessuno] [--years 12] [--size 128] [--threads n] [--out bilanciamento]"; + + public int Run(CommandLine args) + { + Console.OutputEncoding = System.Text.Encoding.UTF8; + var data = GameData.LoadDefault(); + var o = new BalanceOptions + { + Seeds = List(args.String("seeds", "1,2,3")).Select(s => ulong.Parse(s, CultureInfo.InvariantCulture)).ToList(), + Difficulties = List(args.String("difficulties", string.Join(',', data.Difficulty.Presets.Select(p => p.Id)))), + Bots = List(args.String("bots", "bot_competent,bot_prudent")), + Years = args.Int("years", 12), + SizeKm = args.Int("size", 128), + Threads = args.Int("threads", Environment.ProcessorCount), + }; + string output = args.String("out", "bilanciamento"); + args.EnsureAllUsed(); + + var clock = Stopwatch.StartNew(); + int total = o.Seeds.Count * o.Difficulties.Count * o.Bots.Count, finished = 0; + Console.WriteLine($"balance: {total} esecuzioni da {o.Years} anni su {o.SizeKm} km, {o.Threads} in parallelo"); + var runs = BalanceBench.Run(data, o, r => + { + finished++; + Console.WriteLine($" [{finished}/{total}] seme {r.Seed} {r.Difficulty} {r.Bot}: {r.ElapsedMs / 1000.0:F1} s, livello 2 del bot all'anno {(r.BotTierYear.Length > 1 && r.BotTierYear[1] > 0 ? r.BotTierYear[1].ToString(CultureInfo.InvariantCulture) : "mai")}{(r.BotBankrupt ? ", FALLITO" : "")}"); + }); + long wall = clock.ElapsedMilliseconds; + BalanceReport.Write(output, data, o, runs); + long cpu = runs.Sum(r => r.ElapsedMs); + string times = $"tempo totale {wall / 1000.0:F1} s; somma delle esecuzioni {cpu / 1000.0:F1} s; per esecuzione media {cpu / 1000.0 / Math.Max(1, runs.Count):F1} s, massima {runs.Max(r => r.ElapsedMs) / 1000.0:F1} s; {o.Threads} in parallelo\n"; + File.WriteAllText(Path.Combine(output, "tempi.txt"), times); + Console.WriteLine(); + Console.Write(BalanceReport.Text(data, o, runs)); + Console.WriteLine(); + Console.Write(times); + Console.WriteLine($"rapporto e CSV in {output}"); + return 0; + } + + private static List List(string value) => + value.Split(',', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries).ToList(); +} diff --git a/src/RailEnterprise.Tools/Commands/SimulateCommand.cs b/src/RailEnterprise.Tools/Commands/SimulateCommand.cs index 9e3818b..7d26477 100644 --- a/src/RailEnterprise.Tools/Commands/SimulateCommand.cs +++ b/src/RailEnterprise.Tools/Commands/SimulateCommand.cs @@ -17,7 +17,7 @@ public sealed class SimulateCommand : IToolCommand { public string Name => "simulate"; - public string Usage => "simulate --seed --years [--size 128] [--difficulty imprenditore] [--scenario ] [--out kpi.csv] [--save ] [--trace-ai]"; + public string Usage => "simulate --seed --years [--size 128] [--difficulty imprenditore] [--scenario ] [--out kpi.csv] [--save ] [--bot bot_competent] [--trace-ai]"; private static readonly CultureInfo It = CultureInfo.InvariantCulture; @@ -31,6 +31,7 @@ public sealed class SimulateCommand : IToolCommand string output = args.String("out", "kpi.csv"); string? savePath = args.String("save"); bool trace = args.Flag("trace-ai"); + string? bot = args.String("bot"); args.EnsureAllUsed(); if (trace) Core.Simulation.Ai.AiSystem.Trace = Console.WriteLine; @@ -41,6 +42,8 @@ public sealed class SimulateCommand : IToolCommand world = Scenarios.ScenarioLoader.Load(data, scenario).World; else world = WorldFactory.Create(data, new NewGameSettings { Seed = seed, SizeKm = size, DifficultyId = difficulty }); + // bot giocatore (ADR 0025): guida la compagnia del giocatore con una personalità di ai.json → bots + if (bot is not null) world.PlayerBot = Core.Simulation.Ai.PlayerBot.Create(world, bot); long createMs = total.ElapsedMilliseconds; var csv = new StringBuilder(); @@ -95,7 +98,7 @@ public sealed class SimulateCommand : IToolCommand { long revenue = Company.TransportRevenue(c.LastYearEntries); double share = totalCarrier > 0 ? (double)revenue / totalCarrier : 0; - string note = $"{(c.IsPlayer ? "giocatore" : c.AiPersonality)}, rating {c.Rating}, livello {c.Tier}{(c.Bankrupt ? ", bancarotta" : "")}{(c.Merged ? ", fusa" : "")}{AiNote(w, c)}"; + string note = $"{(c.IsPlayer ? w.PlayerBot is { } pb ? "giocatore, " + pb.Personality.Id : "giocatore" : c.AiPersonality)}, rating {c.Rating}, livello {c.Tier}{(c.Bankrupt ? ", bancarotta" : "")}{(c.Merged ? ", fusa" : "")}{AiNote(w, c)}"; bool fleet = w.Trains.Any(t => !t.Removed && t.Owner == c.Id && t.Vehicles.Count > 0); csv.AppendLine(string.Join(';', year.ToString(It), c.Name, "", "", "", "", population.ToString(It), "", fleet ? Dec(Fleet.FleetCondition(w, c.Id)) : "", "", Dec(c.Cash.Lire), Dec(c.NetWorth.Lire), Dec(share), note)); @@ -105,7 +108,7 @@ public sealed class SimulateCommand : IToolCommand /// Diagnostica dell'agente IA: progetti, treni, comandi rifiutati. private static string AiNote(World w, Company c) { - var s = w.AiStates.FirstOrDefault(a => a.Company == c.Id); + var s = c.IsPlayer ? w.PlayerBot?.State : w.AiStates.FirstOrDefault(a => a.Company == c.Id); if (s is null) return ""; int running = s.Projects.Count(p => p.Stage == Core.Simulation.Ai.AiProjectStage.Running); int trains = w.Trains.Count(t => !t.Removed && t.Owner == c.Id); diff --git a/src/RailEnterprise.Tools/Program.cs b/src/RailEnterprise.Tools/Program.cs index f701433..9114316 100644 --- a/src/RailEnterprise.Tools/Program.cs +++ b/src/RailEnterprise.Tools/Program.cs @@ -10,6 +10,7 @@ public static class ToolsProgram new ValidateDataCommand(), new GenMapCommand(), new SimulateCommand(), + new BalanceCommand(), new ProfileCommand(), new BenchCommand(), new SmokeCommand(), diff --git a/tests/RailEnterprise.Tests/Balance/BalanceTests.cs b/tests/RailEnterprise.Tests/Balance/BalanceTests.cs new file mode 100644 index 0000000..f818a89 --- /dev/null +++ b/tests/RailEnterprise.Tests/Balance/BalanceTests.cs @@ -0,0 +1,134 @@ +using RailEnterprise.Core.Commands; +using RailEnterprise.Core.Common; +using RailEnterprise.Core.Economy; +using RailEnterprise.Core.Persistence; +using RailEnterprise.Core.Rail; +using RailEnterprise.Core.Simulation; +using RailEnterprise.Core.Simulation.Ai; +using RailEnterprise.Core.Simulation.Systems; +using RailEnterprise.Tests.Harness; +using RailEnterprise.Tools.Balance; +using static RailEnterprise.Tests.Rail.RailFixture; + +namespace RailEnterprise.Tests.Balance; + +/// Banco di bilanciamento con i bot giocatore e compravendita delle IA (F6, issue #47, ADR 0025). +public static class BalanceTests +{ + /// Esegue la matrice con un thread e con più thread e confronta testo, CSV e hash di ogni esecuzione. + private static List SameReportWithThreads(BalanceOptions o, int threads) + { + var a = BalanceBench.Run(TestData.Data, o with { Threads = 1 }); + var b = BalanceBench.Run(TestData.Data, o with { Threads = threads }); + Assert.Equal(BalanceReport.Text(TestData.Data, o, a), BalanceReport.Text(TestData.Data, o, b)); + Assert.Equal(BalanceReport.YearsCsv(a), BalanceReport.YearsCsv(b)); + Assert.Equal(BalanceReport.MonthsCsv(TestData.Data, a), BalanceReport.MonthsCsv(TestData.Data, b)); + Assert.Equal(BalanceReport.PricesCsv(TestData.Data, a), BalanceReport.PricesCsv(TestData.Data, b)); + Assert.Equal(BalanceReport.RunsCsv(TestData.Data, a), BalanceReport.RunsCsv(TestData.Data, b)); + Assert.Equal(a.Count, b.Count); + for (int i = 0; i < a.Count; i++) + { + Assert.Equal(a[i].FinalHash, b[i].FinalHash, $"hash dell'esecuzione {i}"); + Assert.True(a[i].InvariantsOk, $"invarianti di denaro e merci dell'esecuzione {i}"); + } + return a; + } + + [Test(Description = "Il banco è deterministico: stesso seme, stesso rapporto (testo, CSV e hash) con uno o due mondi in parallelo")] + public static void SameSeedGivesTheSameReport() + { + var o = new BalanceOptions { Seeds = [5, 6], Difficulties = ["imprenditore"], Bots = ["bot_competent"], Years = 2, SizeKm = 64 }; + var runs = SameReportWithThreads(o, threads: 2); + Assert.True(runs.All(r => r.BotCommands > 0), "il bot ha giocato"); + Assert.True(runs.All(r => r.Months.Count == 24), "24 mesi per esecuzione"); + } + + [Test(Slow = true, Description = "Il banco resta deterministico con più mondi in parallelo anche quando bot e IA arrivano al livello 2 e commerciano (ADR 0025)")] + public static void ParallelRunsWithTradingGiveTheSameReport() + { + // 128 km: nel seme 4 in «Apprendista» il bot arriva al livello 2 nel primo anno e commercia + var o = new BalanceOptions { Seeds = [4, 5], Difficulties = ["apprendista", "imprenditore"], Bots = ["bot_competent"], Years = 3 }; + var runs = SameReportWithThreads(o, threads: 4); + long trades = runs.Sum(r => r.BotTrades + r.AiTrades); + Console.WriteLine($" livello 2 del bot agli anni {string.Join(", ", runs.Select(r => r.BotTierYear[1]))}; affari di bot e IA {trades}"); + Assert.True(runs.Any(r => r.BotTierYear[1] > 0), "almeno un bot sblocca la compravendita"); + Assert.True(trades > 0, "la compravendita delle IA e dei bot è stata esercitata"); + } + + [Test(Slow = true, Description = "Banco ridotto sui semi di verifica 4–9, non usati nella taratura (ADR 0025): in «Imprenditore» il bot competente non fallisce, paga interessi entro il 20 % dei ricavi, pochi rifiuti, invarianti; almeno un bot al livello 2 entro il 6° anno")] + public static void BenchMeetsTheMainGoals() + { + var o = new BalanceOptions { Seeds = [4, 5, 6, 7, 8, 9], Difficulties = ["imprenditore"], Bots = ["bot_competent"], Years = 6 }; + var runs = BalanceBench.Run(TestData.Data, o); + var goals = BalanceReport.Goals(TestData.Data, runs); + foreach (var g in goals) Console.WriteLine($" {(g.Met is null ? "—" : g.Met.Value ? "sì" : "NO")} {g.Id} {g.Text}: {g.Measured}"); + foreach (var id in new[] { "O5", "O12", "O13", "O14" }) + { + var g = goals.Single(x => x.Id == id); + Assert.True(g.Met == true, $"{g.Id} {g.Text}: {g.Measured}"); + } + // O1 non è raggiunto sui semi di verifica (ADR 0025: livello 2 al 4° anno in 3 semi su 6, poi all'8°, + // al 10° o mai): il test ne controlla solo il crollo + Assert.True(runs.Any(r => r.BotTierYear[1] > 0), $"nessun bot al livello 2 in {o.Years} anni: {goals.Single(x => x.Id == "O1").Measured}"); + } + + [Test(Description = "Il bot guida la compagnia del giocatore con i comandi, non entra nel salvataggio e il mondo resta deterministico")] + public static void BotDrivesThePlayerAndIsNotSaved() + { + static World Make() + { + var w = TestWorlds.Small(11); + w.PlayerBot = PlayerBot.Create(w, "bot_competent"); + return w; + } + var a = Make(); + var b = Make(); + a.RunYears(1); + b.RunYears(1); + Assert.Equal(StateHasher.Compute(a), StateHasher.Compute(b)); + Assert.True(a.PlayerBot!.State.Issued > 0, "il bot emette comandi"); + Assert.True(a.Network.Stations.Any(s => s.Owner == a.Player.Id), "stazioni del giocatore costruite dal bot"); + Assert.True(a.PlayerBot.State.RejectedShare <= a.Data.Ai.Planning.MaxRejectedShare, $"rifiutati {a.PlayerBot.State.Rejected} su {a.PlayerBot.State.Issued}"); + Assert.Equal(a.Companies.Count(c => !c.IsPlayer), a.AiStates.Count); + var loaded = SaveFile.Load(TestData.Data, SaveFile.Save(a, "test")); + Assert.True(loaded.PlayerBot is null, "il bot non è salvato"); + Assert.Equal(StateHasher.Compute(a), StateHasher.Compute(loaded)); + Assert.Throws(() => PlayerBot.Create(a, "expansive")); + } + + [Test(Description = "Compravendita delle IA (ADR 0016 §9): con il produttore pieno e il consumatore a secco nello stesso bacino l'agente compra e vende, senza comandi rifiutati")] + public static void AgentTradesWhenTheMarginPays() + { + var f = Valdoria(); + var w = f.W; + // stazione tra l'acciaieria e la fabbrica di attrezzi: produttore e consumatore dell'acciaio nello stesso bacino + int hub = f.Ok(new BuildStationCommand(K(11.7, 3.7), 2, "Acciaierie")); + var station = w.Network.Stations[hub]; + var mill = w.Industries.First(i => i.Def.Id == "steel_mill"); + var tools = w.Industries.First(i => i.Def.Id == "tool_factory"); + Assert.True(station.Industries.Contains(mill.Id) && station.Industries.Contains(tools.Id), "bacino con acciaieria e fabbrica"); + w.Player.Tier = w.Data.Tiers.Tiers.First(t => t.Unlocks.Trading).Level; + int steel = w.Data.Goods.First(g => g.Id == "steel").Index; + int cap = IndustryMath.OutputCapacity(mill, 0, w.Calendar.DaysPerMonth); + w.Goods.Produced[steel] += cap - mill.OutputStock[0]; + mill.OutputStock[0] = cap; + int input = tools.InputIndexOf(steel); + w.Goods.Decayed[steel] += tools.InputStock[input]; + tools.InputStock[input] = 0; + var q = TradingMath.Quote(w, station, steel); + Assert.True((q.SellPrice - q.BuyPrice) / q.BuyPrice > w.Data.Ai.Trading.MinMargin, $"margine atteso: compra {q.BuyPrice:0}, vende {q.SellPrice:0}"); + + w.PlayerBot = PlayerBot.Create(w, "bot_competent"); + long millCash = mill.Cash.Cents, toolsCash = tools.Cash.Cents; + w.RunDays(w.Calendar.DaysPerMonth + 1); + long trading = w.Player.YearEntries[(int)LedgerEntry.Trading]; + Assert.True(mill.Cash.Cents > millCash, "l'acciaieria ha venduto acciaio alla compagnia"); + Assert.True(tools.Cash.Cents < toolsCash, "la fabbrica di attrezzi ha comprato l'acciaio"); + Assert.True(trading > 0, $"utile della compravendita: {trading} centesimi"); + Assert.Equal(0, station.StockOf(steel), "rivenduto subito alla fabbrica"); + Assert.Equal(0L, w.PlayerBot.State.Rejected, "nessun comando rifiutato"); + Assert.Equal(0L, w.MoneyBalanceSum()); + for (int g = 0; g < w.Data.GoodCount; g++) + Assert.Equal(w.Goods.ExpectedStock(g), w.TotalStock(g), $"merce {w.Data.Goods[g].Id}"); + } +} diff --git a/tests/RailEnterprise.Tests/Data/DataTests.cs b/tests/RailEnterprise.Tests/Data/DataTests.cs index 56ffdf1..8f28e16 100644 --- a/tests/RailEnterprise.Tests/Data/DataTests.cs +++ b/tests/RailEnterprise.Tests/Data/DataTests.cs @@ -120,6 +120,25 @@ public static class DataTests Assert.True(errors.Any(e => e.Contains("balance.json", StringComparison.Ordinal))); } + [Test(Description = "I valori di taratura del bilanciamento (ai.json → planning, balance.json → market.world) hanno limiti nello schema (ADR 0025)")] + public static void SchemaBoundsTheBalanceTuning() + { + var errors = LoadErrors(files => + { + var bal = JsonNode.Parse(files["balance.json"])!; + bal["market"]!["world"]!["elasticity"] = -2.5; + bal["market"]!["world"]!["volumeShare"] = "1"; + files["balance.json"] = bal.ToJsonString(); + var ai = JsonNode.Parse(files["ai.json"])!; + ai["planning"]!["townRoiFactor"] = -0.35; + ai["planning"]!["partsDeferYears"] = -1; + ai["planning"]!["townBonuss"] = 3.0; + files["ai.json"] = ai.ToJsonString(); + }); + foreach (var key in new[] { "elasticity", "volumeShare", "townRoiFactor", "partsDeferYears", "townBonuss" }) + Assert.True(errors.Any(e => e.Contains(key, StringComparison.Ordinal)), $"{key} non segnalato: {string.Join("; ", errors)}"); + } + [Test] public static void SemanticRejectsBrokenFailureShares() { diff --git a/tests/RailEnterprise.Tests/Economy/EconomyTests.cs b/tests/RailEnterprise.Tests/Economy/EconomyTests.cs index 5ad87c6..a5c4a8a 100644 --- a/tests/RailEnterprise.Tests/Economy/EconomyTests.cs +++ b/tests/RailEnterprise.Tests/Economy/EconomyTests.cs @@ -46,9 +46,10 @@ public static class EconomyTests var w = TestWorlds.Small(103); int food = w.Data.GoodIndex("food"); double before = w.Market.GlobalPrice[food]; - // nessuna produzione di alimentari raggiunge il mercato: la domanda cittadina spinge il prezzo + // nessuna produzione di alimentari raggiunge il mercato: la domanda cittadina spinge il prezzo; il resto + // del mondo (volume pieno ed elasticità 2,5, ADR 0025) ne assorbe una parte, quindi la salita è più dolce w.RunDays(120); - Assert.True(w.Market.GlobalPrice[food] > before * 1.5, $"prezzo alimentari {before} → {w.Market.GlobalPrice[food]}"); + Assert.True(w.Market.GlobalPrice[food] > before * 1.25, $"prezzo alimentari {before} → {w.Market.GlobalPrice[food]}"); } [Test] diff --git a/tests/RailEnterprise.Tests/RailEnterprise.Tests.csproj b/tests/RailEnterprise.Tests/RailEnterprise.Tests.csproj index e706278..a162406 100644 --- a/tests/RailEnterprise.Tests/RailEnterprise.Tests.csproj +++ b/tests/RailEnterprise.Tests/RailEnterprise.Tests.csproj @@ -11,6 +11,7 @@ +