F6: bilanciamento con i bot su simulate #53

Merged
Alby96 merged 3 commits from claude/f6-bilanciamento into main 2026-11-15 11:36:50 +01:00
25 changed files with 1959 additions and 49 deletions

No files matched your search

+1 -1
View File
@@ -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 -- <comando> # validate-data, genmap, profile, simulate, bench, replay
dotnet run --project src/RailEnterprise.Tools -- <comando> # validate-data, genmap, profile, simulate, balance, bench, replay
```
## Regole non negoziabili
+18 -3
View File
@@ -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"
+1 -1
View File
@@ -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 }
+324 -11
View File
@@ -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
}
+62 -10
View File
@@ -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",
+2 -2
View File
@@ -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
+21 -6
View File
@@ -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 <id>`;
- 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 |
+1 -1
View File
@@ -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
+247
View File
@@ -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 <id>` 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).
+37
View File
@@ -12,7 +12,14 @@ public sealed class AiFile
public required AiMarketParams Market { get; init; }
/// <summary>Rinnovo dei treni con veicoli superati (F6, ADR 0020).</summary>
public required AiRenewalParams Renewal { get; init; }
/// <summary>Compravendita in proprio delle IA (F6, ADR 0016 §9 e ADR 0025).</summary>
public required AiTradingParams Trading { get; init; }
public required List<AiPersonalityDef> Personalities { get; init; }
/// <summary>
/// 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.
/// </summary>
public required List<AiPersonalityDef> Bots { get; init; }
public required List<string> CompanyNames { get; init; }
public required List<string> Colors { get; init; }
}
@@ -77,6 +84,12 @@ public sealed class AiPlanningParams
public required int PlanningDaySpacing { get; init; }
/// <summary>Candidati falliti ricordati per non riprovarli.</summary>
public required int FailedMemory { get; init; }
/// <summary>
/// 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.
/// </summary>
public required double PartsDeferYears { get; init; }
}
/// <summary>
@@ -94,6 +107,30 @@ public sealed class AiRenewalParams
public required int MaxTrainsPerMonth { get; init; }
}
/// <summary>
/// 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
/// <see cref="MinSellPriceShare"/> 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 <see cref="MinMargin"/>. Al più
/// <see cref="MaxTradesPerMonth"/> operazioni da <see cref="MaxUnits"/> unità, con al più
/// <see cref="CashShare"/> della cassa libera oltre <see cref="CashReserveMultiple"/> volte la riserva.
/// </summary>
public sealed class AiTradingParams
{
public required bool Enabled { get; init; }
/// <summary>Margine minimo atteso (vendita − acquisto) / acquisto sulla prossima unità.</summary>
public required double MinMargin { get; init; }
/// <summary>Scarto ammesso sul prezzo della prossima unità: tetto d'acquisto e minimo di vendita.</summary>
public required double PriceSlack { get; init; }
/// <summary>Si vende la merce in magazzino solo a chi paga almeno questa quota del prezzo globale.</summary>
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; }
}
/// <summary>Comportamento in borsa delle IA (12.1–12.2).</summary>
public sealed class AiMarketParams
{
@@ -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)
{
@@ -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)
/// <summary>Occasione di compravendita: comprare un bene in una stazione e venderlo lì o in un'altra raggiungibile.</summary>
private readonly record struct Deal(Station From, Station To, int Good, double BuyPrice, double SellPrice, int Units)
{
public double Profit => Units * (SellPrice - BuyPrice);
}
/// <summary>
/// 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.
/// </summary>
private void Trade()
{
var t = _w.Data.Ai.Trading;
if (!t.Enabled) return;
var stations = new List<Station>();
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<Deal>();
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<int>(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})");
}
}
/// <summary>Aggiunge l'occasione se i compratori della destinazione pagano la prossima unità con il margine minimo.</summary>
private void Consider(List<Deal> 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));
}
/// <summary>Vende la merce dei magazzini propri ai compratori del bacino che pagano almeno la quota minima del prezzo globale.</summary>
private void SellStock(AiTradingParams t, List<Station> 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; }
/// <summary>Parte del capitale spesa dopo, con i ricavi della linea: la linea dei ricambi del deposito (ADR 0025).</summary>
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;
}
/// <summary>
/// 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.
/// </summary>
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;
}
/// <summary>
/// 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
/// <summary>Apre i cantieri del progetto: stazioni, deposito, binario e raccordo del deposito.</summary>
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;
@@ -59,6 +59,14 @@ public sealed class AiState
/// <summary>Ultimo giorno in cui l'IA ha sciolto uno stallo (uno ogni tanto, non a cascata).</summary>
public long LastGridlockDay { get; set; } = -1_000_000;
/// <summary>
/// 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).
/// </summary>
public long PartsBlockedMonths { get; set; }
public long Trades { get; set; }
/// <summary>Quota dei comandi rifiutati sul totale emesso.</summary>
public double RejectedShare => Issued == 0 ? 0 : (double)Rejected / Issued;
}
@@ -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);
@@ -0,0 +1,37 @@
using RailEnterprise.Core.Data;
namespace RailEnterprise.Core.Simulation.Ai;
/// <summary>
/// «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 <c>bots</c> 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.
/// </summary>
public sealed class PlayerBot
{
private PlayerBot(AiPersonalityDef personality, AiState state)
{
Personality = personality;
State = state;
}
public AiPersonalityDef Personality { get; }
/// <summary>Stato dell'agente (progetti, comandi emessi e rifiutati), come per le IA.</summary>
public AiState State { get; }
/// <summary>Bot con la personalità indicata (id di ai.json → bots) per la compagnia del giocatore.</summary>
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);
}
}
@@ -76,6 +76,12 @@ public sealed class World
/// <summary>Agenti IA sospesi (le compagnie IA esistono ma non agiscono): test e scenari didattici.</summary>
public bool AiPaused { get; set; }
/// <summary>
/// Bot che guida la compagnia del giocatore (banco di bilanciamento, ADR 0025), null di norma.
/// Non è salvato: un mondo caricato riparte senza bot.
/// </summary>
public Ai.PlayerBot? PlayerBot { get; set; }
/// <summary>Ultimo anno in cui è entrato un nuovo concorrente (12.1).</summary>
public int LastCompetitorYear { get; set; } = int.MinValue;
@@ -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;
/// <summary>Matrice del banco di bilanciamento: semi × difficoltà × bot, per un numero di anni (ADR 0025).</summary>
public sealed record BalanceOptions
{
public required IReadOnlyList<ulong> Seeds { get; init; }
public required IReadOnlyList<string> Difficulties { get; init; }
/// <summary>Id dei bot di ai.json → bots; «nessuno» lascia il giocatore passivo.</summary>
public required IReadOnlyList<string> Bots { get; init; }
public int Years { get; init; } = 12;
public int SizeKm { get; init; } = 128;
/// <summary>Esecuzioni in parallelo (ogni mondo è indipendente: il risultato non cambia).</summary>
public int Threads { get; init; } = Environment.ProcessorCount;
}
/// <summary>Una compagnia alla fine di un anno di gioco.</summary>
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);
/// <summary>Un mese di gioco: prezzi, margini dei trasformatori, coperture, popolazione.</summary>
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);
/// <summary>Esito di un'esecuzione della matrice.</summary>
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<CompanyYearRow> YearRows { get; } = [];
public List<MonthRow> Months { get; } = [];
/// <summary>Anno di gioco (1 = il primo) in cui il bot ha raggiunto ciascun livello, 0 se mai (indice = livello − 1).</summary>
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; }
/// <summary>IA con almeno una linea in esercizio alla fine del terzo anno.</summary>
public int AiActiveByYear3 { get; set; }
/// <summary>IA presenti alla fine del terzo anno (denominatore di O11), −1 se la partita è più corta.</summary>
public int AiAtYear3 { get; set; } = -1;
public int BestAiTier { get; set; }
/// <summary>Anno di gioco in cui la prima IA ha raggiunto il livello 2, 0 se mai.</summary>
public int AiTier2Year { get; set; }
/// <summary>Ampliamenti di livello delle industrie e mesi-industria serviti (ritmo di crescita, ADR 0025).</summary>
public int LevelUps { get; set; }
public int ServedIndustryMonths { get; set; }
/// <summary>Livello più alto raggiunto da un'industria.</summary>
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; }
/// <summary>Mesi senza reti nuove perché un deposito aspettava la linea dei ricambi (bot, somma delle IA).</summary>
public long BotPartsBlockedMonths { get; set; }
public long AiPartsBlockedMonths { get; set; }
/// <summary>Affari di compravendita conclusi dal bot e dalle IA.</summary>
public long BotTrades { get; set; }
public long AiTrades { get; set; }
public ulong FinalHash { get; set; }
public bool InvariantsOk { get; set; }
/// <summary>Durata in millisecondi (non entra nel rapporto deterministico).</summary>
public long ElapsedMs { get; set; }
}
/// <summary>
/// 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.
/// </summary>
public static class BalanceBench
{
public const string NoBot = "nessuno";
public static List<BalanceRun> Run(GameData data, BalanceOptions o, Action<BalanceRun>? 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];
}
/// <summary>Una partita: crea il mondo, mette il bot e la fa girare mese per mese.</summary>
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<long>();
var lastEma = new List<double>();
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;
}
/// <summary>Vendite giornaliere minime (centesimi) perché un giorno conti come giorno con vendite (soglia del banco).</summary>
public const double MinDailySalesCents = 1;
private static MonthRow SampleMonth(World w, int monthIndex, List<long> 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));
}
}
}
@@ -0,0 +1,433 @@
using System.Globalization;
using System.Text;
using RailEnterprise.Core.Data;
namespace RailEnterprise.Tools.Balance;
/// <summary>Esito di un obiettivo dell'ADR 0025 sulla matrice eseguita.</summary>
public sealed record GoalResult(string Id, string Text, string Measured, bool? Met);
/// <summary>
/// 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.
/// </summary>
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;
/// <summary>Mediana degli anni (0 = mai, contato come oltre la fine) come testo.</summary>
/// <summary>Con un numero pari di semi la mediana sono i due valori centrali («4–8»).</summary>
private static string MedianYear(IEnumerable<int> 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)}";
}
/// <summary>
/// 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.
/// </summary>
private static (int Lo, int Hi) MedianYearValue(IEnumerable<int> 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]);
}
/// <summary>Quanti anni stanno nella fascia [from, to], come «3 su 6».</summary>
private static string InBand(IEnumerable<int> 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<long> 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();
/// <summary>Obiettivi dell'ADR 0025 misurati sulle esecuzioni (null = combinazione non eseguita).</summary>
public static List<GoalResult> Goals(GameData data, List<BalanceRun> runs)
{
var goals = new List<GoalResult>();
int horizon = runs.Count == 0 ? 0 : runs.Max(r => r.Years);
List<BalanceRun> 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<double>();
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<string>();
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);
/// <summary>Il bot ha giocato: almeno una linea in esercizio alla fine di un anno (gli obiettivi O3–O5 contano solo queste partite).</summary>
public static bool Played(BalanceRun r) => r.YearRows.Any(y => y.IsBot && y.RunningLines > 0);
/// <summary>Fallimenti del bot sulle partite giocate; quelle senza linee si dichiarano e non contano.</summary>
private static GoalResult Bankruptcies(string id, string text, List<BalanceRun> 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);
}
/// <summary>
/// Una partita per seme e difficoltà per gli obiettivi del mondo: quella del bot competente se c'è,
/// altrimenti la prima del piano.
/// </summary>
public static List<BalanceRun> WorldRuns(List<BalanceRun> runs)
{
var list = new List<BalanceRun>();
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;
}
/// <summary>
/// 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).
/// </summary>
public static (double Low, double High) PriceBand(double volatility)
{
double v = Math.Max(1, volatility);
return (1 - (1 - PriceLow) * v, 1 + (PriceHigh - 1) * v);
}
/// <summary>Crescita media annua composta della popolazione complessiva.</summary>
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;
/// <summary>Testo del rapporto (deterministico: non contiene tempi).</summary>
public static string Text(GameData data, BalanceOptions o, List<BalanceRun> 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<string>();
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();
}
/// <summary>Scrive rapporto.txt e i CSV nella cartella indicata.</summary>
public static void Write(string dir, GameData data, BalanceOptions o, List<BalanceRun> 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<BalanceRun> 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<BalanceRun> 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<BalanceRun> 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<BalanceRun> 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();
}
}
@@ -0,0 +1,58 @@
using System.Diagnostics;
using System.Globalization;
using RailEnterprise.Core.Data;
using RailEnterprise.Tools.Balance;
namespace RailEnterprise.Tools.Commands;
/// <summary>
/// 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.
/// </summary>
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<string> List(string value) =>
value.Split(',', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries).ToList();
}
@@ -17,7 +17,7 @@ public sealed class SimulateCommand : IToolCommand
{
public string Name => "simulate";
public string Usage => "simulate --seed <n> --years <n> [--size 128] [--difficulty imprenditore] [--scenario <file>] [--out kpi.csv] [--save <file>] [--trace-ai]";
public string Usage => "simulate --seed <n> --years <n> [--size 128] [--difficulty imprenditore] [--scenario <file>] [--out kpi.csv] [--save <file>] [--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
/// <summary>Diagnostica dell'agente IA: progetti, treni, comandi rifiutati.</summary>
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);
+1
View File
@@ -10,6 +10,7 @@ public static class ToolsProgram
new ValidateDataCommand(),
new GenMapCommand(),
new SimulateCommand(),
new BalanceCommand(),
new ProfileCommand(),
new BenchCommand(),
new SmokeCommand(),
@@ -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;
/// <summary>Banco di bilanciamento con i bot giocatore e compravendita delle IA (F6, issue #47, ADR 0025).</summary>
public static class BalanceTests
{
/// <summary>Esegue la matrice con un thread e con più thread e confronta testo, CSV e hash di ogni esecuzione.</summary>
private static List<BalanceRun> 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<ArgumentException>(() => 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}");
}
}
@@ -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()
{
@@ -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]
@@ -11,6 +11,7 @@
<ProjectReference Include="..\..\src\RailEnterprise.Core\RailEnterprise.Core.csproj" />
<ProjectReference Include="..\..\src\RailEnterprise.Protocol\RailEnterprise.Protocol.csproj" />
<ProjectReference Include="..\..\src\RailEnterprise.Server\RailEnterprise.Server.csproj" />
<ProjectReference Include="..\..\src\RailEnterprise.Tools\RailEnterprise.Tools.csproj" />
</ItemGroup>
<!-- Logica pura del tutorial del client (senza Godot, ADR 0023): compilata anche qui per provarla. -->