F2: pendolarismo su rotaia, carichi per linea, accettazione Valdoria e bench
- Abbinamento mensile dei pendolari sul LineGraph (60/90 minuti con i tratti a piedi, quote proporzionali ai lavoratori liberi, capacità residua delle linee), pacchetti giornalieri, coperture e scioglimento dei contratti. - LineGraph con maschere dei carichi: merci, lavoratori e personale viaggiano solo su linee i cui treni li possono portare; durata dei giri con le soste di carico e scarico. - Industria servita = merce ritirata o consegnata dal vettore. - Parametri residui spostati in data/*.json. - Test di accettazione F2 sullo scenario Valdoria con tre linee, test del pendolarismo (copertura > 0,9 in 60 giorni, capacità, scioglimento). - viaferrea-tools bench: 2.000 treni, tick medio 0,84 ms. - ADR 0007 e 0008, ARCHITECTURE e STATE aggiornati. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_0191R7vXgtbAvSV4V8tj8uzL
This commit is contained in:
27 files changed
+953
-84
No files matched your search
+7
-3
@@ -33,7 +33,7 @@
|
||||
"preferredMaxPercentile": { "coal": 0.92, "iron": 1.0, "stone": 0.95, "oil": 0.45 } },
|
||||
"towns": { "countBySize": { "64": 10, "128": 26, "256": 56 }, "minDistanceKm": 6, "maxWaterDistanceKm": 3, "maxSlope": 0.05,
|
||||
"maxHeightPercentile": 0.65, "largestPopulation": [ 11000, 18000 ], "zipfExponent": 0.85, "minPopulation": 500,
|
||||
"radiusBaseCells": 2.0, "radiusPerSqrtPop": 0.025 },
|
||||
"radiusBaseCells": 2.0, "radiusPerSqrtPop": 0.025, "radiusHysteresisCells": 0.25 },
|
||||
"industries": { "countBySize": { "64": 32, "128": 110, "256": 400 }, "initialLevels": [ 1, 2 ],
|
||||
"shares": { "farm": 0.35, "logging": 0.12, "processing": 0.33, "manufacturing": 0.20 }, "placementAttempts": 400,
|
||||
"maxSlope": 0.15, "spacingCells": 1 },
|
||||
@@ -48,7 +48,7 @@
|
||||
"ratioMin": 0.2,
|
||||
"ratioMax": 5.0,
|
||||
"world": { "amplitude": 0.12, "periodYears": 6, "volumeShare": 0.5, "baselinePerDay": 4.0, "elasticity": 1.0,
|
||||
"shockChancePerYear": 0.25, "shockMin": 0.08, "shockMax": 0.30, "shockDecayDays": 150 },
|
||||
"shockChancePerYear": 0.25, "shockMin": 0.08, "shockMax": 0.30, "shockDecayDays": 150, "priceFloor": 0.05 },
|
||||
"historyDays": 360
|
||||
},
|
||||
"localPrice": { "lambda": 0.35, "maxDeviation": 0.40, "epsilon": 1.0 },
|
||||
@@ -99,12 +99,16 @@
|
||||
"initialSatisfaction": 0.5,
|
||||
"stockDays": 20,
|
||||
"workSatisfactionPenalty": 0.05,
|
||||
"workDissatisfactionDecayDays": 90,
|
||||
"demandPriceFactorMin": 0.5,
|
||||
"demandPriceFactorMax": 1.5,
|
||||
"populationMilestone": 10000,
|
||||
"maxPopulation": 2000000
|
||||
},
|
||||
"migration": { "share": 0.01, "satisfactionThreshold": 0.4, "maxDistanceKm": 60, "emigrationShareWhenNoTarget": 0.5 },
|
||||
"employment": { "walkRadiusKm": 1.5, "workerMaxMinutes": 60, "staffMaxMinutes": 90, "coverageEmaDays": 30,
|
||||
"dissolveCoverage": 0.5, "dissolveDays": 90, "walkSpeedKmh": 4.5, "boardDays": 2, "returnBoardDays": 2,
|
||||
"railStartCoverage": 0.5 },
|
||||
"railStartCoverage": 0.5, "lineCapacityUtilization": 0.85 },
|
||||
"localTransport": { "enabled": true, "radiusKm": 3.0, "dailyShare": 0.25, "maxUnitsPerDay": 6 },
|
||||
"hubs": {
|
||||
"port": { "name_it": "Porto", "monthlyCapacity": 3000, "duty": 0.08, "footprint": "large" },
|
||||
|
||||
+10
-5
@@ -70,15 +70,17 @@
|
||||
"missedInspectionWearPerDay": 0.03,
|
||||
"speedLimitBelow": 50,
|
||||
"speedLimitFactor": 0.5,
|
||||
"closeBelow": 15
|
||||
"closeBelow": 15,
|
||||
"closedSpeedFactor": 0.1,
|
||||
"agingYearsToZero": 10
|
||||
},
|
||||
"stations": {
|
||||
"catchmentKm": 2.0,
|
||||
"areaRadiusM": 120,
|
||||
"maxPlatforms": 8,
|
||||
"snapM": 60,
|
||||
"freightUnitsPerMinutePerWagon": 2.0,
|
||||
"paxPerMinutePerCoach": 12,
|
||||
"freightUnitsPerMinutePerWagon": 5.0,
|
||||
"paxPerMinutePerCoach": 30,
|
||||
"minDwellMinutes": 3,
|
||||
"upkeepPerPlatformPerYear": 60000,
|
||||
"depotUpkeepPerYear": { "small": 120000, "medium": 240000, "large": 480000 }
|
||||
@@ -88,7 +90,9 @@
|
||||
"maxTurnDeg": 100,
|
||||
"lookaheadMarginM": 60,
|
||||
"waitWarningDays": 20,
|
||||
"defaultMaxWaitDays": 2
|
||||
"defaultMaxWaitDays": 2,
|
||||
"lineRunTimeMargin": 1.15,
|
||||
"defaultLineSpeedKmh": 60
|
||||
},
|
||||
"physics": {
|
||||
"gravity": 9.81,
|
||||
@@ -99,6 +103,7 @@
|
||||
"cxByKind": { "locomotive": 6.0, "wagon": 1.5, "coach": 1.8 },
|
||||
"brakingMs2": 0.5,
|
||||
"stallSpeedKmh": 1.0,
|
||||
"stallSeconds": 120
|
||||
"stallSeconds": 120,
|
||||
"passengerMassT": 0.08
|
||||
}
|
||||
}
|
||||
+17
-7
@@ -28,7 +28,7 @@ Regole:
|
||||
| `ViaFerrea.Core.Data` | Definizioni immutabili caricate da `data/*.json` (`GameData`), contesto JSON con source generator, validatore di schema e validatore semantico. |
|
||||
| `ViaFerrea.Core.Map` | `Terrain` (altezze `ushort` in decimetri, tipi cella `byte`, larghezza dei fiumi), `MapGenerator` (ADR 0005), `ValueNoise`, `TerrainSampler`, `NameGenerator`, chunk 64×64. |
|
||||
| `ViaFerrea.Core.Economy` | Città, industrie, hub, mercato, compagnie, registro contabile a partita doppia, finanza. |
|
||||
| `ViaFerrea.Core.Rail` *(F2)* | `TrackPlanner`, opere e cantieri, `TrackGraph`, stazioni, depositi, segnali, treni, linee, `LineGraph`, pacchetti, tariffe. |
|
||||
| `ViaFerrea.Core.Rail` | `TrackGeometry` (raccordi), `TrackPlanner` (profilo a 25 m, opere, costi, tempi, vincoli per era), `RailNetwork` (nodi, archi campionati, stazioni, depositi, cantieri, indice spaziale), `Pathfinder` (A* sugli archi orientati), veicoli, treni, linee, pacchetti, `LineGraph` con maschere dei carichi (ADR 0007, 0008). |
|
||||
| `ViaFerrea.Core.Commands` | Comandi di gioco (record immutabili) ed esiti. Sono l'unico modo di cambiare il mondo dall'esterno, anche per le IA. |
|
||||
| `ViaFerrea.Core.Simulation` | `World`, `WorldContext`, `SystemPipeline` e `Systems/`, `WorldFactory`, `IndustryPlacer`, `CommandProcessor`, eventi in uscita. |
|
||||
| `ViaFerrea.Core.Persistence` | `SaveWriter`/`SaveReader`, `SaveFile` (Brotli), `StateHasher`. |
|
||||
@@ -43,22 +43,26 @@ Clock → Commands → Construction → Trains → Signals → Stations → Main
|
||||
→ Finance → StockMarket → AiAgents (mensile) → Events → Contracts → Hash (giornaliero)
|
||||
```
|
||||
|
||||
Sistemi implementati (F1), nella loro posizione:
|
||||
Sistemi implementati (F1–F2), nella loro posizione:
|
||||
|
||||
| Sistema | Frequenza | Cosa fa |
|
||||
|---|---|---|
|
||||
| `ClockSystem` | tick | calcola una volta gli indicatori di giorno, mese, trimestre, anno |
|
||||
| `CommandSystem` | tick | drena la coda dei comandi (`CommandProcessor`), registra esiti ed eventualmente il log per il replay |
|
||||
| `ConstructionSystem` | giorno | squadre e cantieri, usura e manutenzione del binario, ispezioni e invecchiamento di ponti e gallerie |
|
||||
| `TrainSystem` | tick | percorsi, prenotazioni di blocchi, versi e binari di stazione fino al punto sicuro, fisica, soste, carico e scarico (`StationWork`), `Stalled` |
|
||||
| `StationSystem` | giorno | bacini (mensili), scadenze dei pacchetti, consegne in attesa del consumatore, ritiro della produzione verso la destinazione migliore |
|
||||
| `LocalTransportSystem` | giorno | trasporto locale su strada tra produttori, consumatori e hub entro 3 km (posto di «Stations», ADR 0004) |
|
||||
| `DemandSystem` | giorno | domanda delle città (con elasticità) e input richiesti dalle industrie |
|
||||
| `EmploymentSystem` | giorno/mese | servizi cittadini, lavoratori in sede, contratti a piedi; presenze e coperture (posto di «Commuting») |
|
||||
| `EmploymentSystem` | giorno/mese | servizi cittadini, lavoratori in sede, contratti a piedi e su rotaia (abbinamento mensile sul `LineGraph`), pacchetti giornalieri dei pendolari, presenze e coperture (posto di «Commuting», ADR 0008) |
|
||||
| `IndustrySystem` | giorno/trimestre/anno | produzione, esaurimento giacimenti, salari, crescita delle industrie servite, chiusure, nascite |
|
||||
| `TownSystem` | giorno/mese/anno | consumo e soddisfazione, crescita, migrazione, espansione dell'abitato |
|
||||
| `MarketSystem` | giorno | prezzi globali con componente mondiale e shock, domanda insoddisfatta |
|
||||
| `FinanceSystem` | giorno/mese/anno | cassa negativa e bancarotta, rate dei prestiti, rating, chiusura dei conti |
|
||||
| `FinanceSystem` | giorno/mese/anno | costi di esercizio di veicoli, stazioni e depositi, valori di libro, cassa negativa e bancarotta, rate dei prestiti, rating, chiusura dei conti |
|
||||
| `HashSystem` | giorno | hash dello stato dinamico |
|
||||
|
||||
- Ogni sistema implementa `ISimSystem.Step(WorldContext ctx)`; i sistemi giornalieri o mensili controllano `ctx.IsNewDay` / `ctx.IsNewMonth` e ritornano subito negli altri tick: 239 tick su 240 costano pochi nanosecondi finché non arrivano i treni.
|
||||
- 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, le IA dal proprio sistema; il sistema `Commands` la drena a inizio tick. 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).
|
||||
@@ -84,7 +88,7 @@ Requisito: stesso seme + stessi comandi agli stessi tick ⇒ stesso hash di stat
|
||||
|
||||
- Entità in `ViaFerrea.Core.Economy`: `Town`, `Industry`, `Hub`, `ResourceSite`, `Company` (con `Loan`), `CommuteContract`, `Market`, `Tariffs`.
|
||||
- Ogni movimento di denaro passa dal registro (`MoneyLedger.Transfer`) tra conti: compagnie, industrie e il conto `Esterno` (famiglie, clienti delle tariffe, mercato mondiale). La somma di tutti i saldi è sempre zero: è l'invariante «denaro» dei test. Le voci del conto economico delle compagnie (`LedgerEntry`) si accumulano per mese e per anno.
|
||||
- Ogni unità di merce sta in un magazzino tracciato (industrie, città; da F2 stazioni, depositi, treni, pacchetti) e `GoodsCounters` registra prodotto, consumato, deperito, importato, esportato: giacenza = prodotto + importato − consumato − deperito − esportato. È l'invariante «merci».
|
||||
- Ogni unità di merce sta in un magazzino tracciato (industrie, città, pacchetti in stazione e a bordo dei treni) e `GoodsCounters` registra prodotto, consumato, deperito, importato, esportato: giacenza = prodotto + importato − consumato − deperito − esportato. È l'invariante «merci».
|
||||
- Interpretazioni delle formule della guida: ADR 0004.
|
||||
|
||||
## 7. Salvataggi
|
||||
@@ -105,8 +109,14 @@ Requisito: stesso seme + stessi comandi agli stessi tick ⇒ stesso hash di stat
|
||||
- Livelli di rendering: terreno per chunk (texture con fasce altimetriche, hillshade, curve di livello), binari e opere, entità, treni interpolati; LOD a zoom ridotto.
|
||||
- `LocalServerLauncher` avvia il server come processo figlio per la partita in locale.
|
||||
|
||||
## 6 bis. Rete e circolazione
|
||||
|
||||
- Il binario è un grafo di nodi (estremità, scambi, stazioni, depositi) e archi campionati ogni 25 m con quota, opera e velocità ammessa. Gli archi si percorrono nei due versi; il doppio binario ha un binario per verso.
|
||||
- I treni seguono un percorso A* fino alla prossima fermata e avanzano prenotando sezioni di blocco; sul binario semplice prenotano il verso fino al primo punto sicuro (ADR 0007).
|
||||
- Le merci viaggiano in pacchetti (struct) con tratto corrente (linea, stazione di discesa); i pendolari sono pacchetti dei contratti. Il `LineGraph` per compagnia si ricostruisce quando cambia la versione di rete o linee (ADR 0008).
|
||||
|
||||
## 10. Prestazioni
|
||||
|
||||
- Treni e pacchetti in array di struct, nessuna allocazione nel tick.
|
||||
- Treni e pacchetti in liste di struct riutilizzate; nel tick ordinario si alloca meno di 1 KB (crescita delle liste), nessuna raccolta gen0 durante `bench`.
|
||||
- Sistemi giornalieri e mensili distribuiti: i calcoli pesanti (abbinatore del pendolarismo, pianificatore di manutenzione, IA) girano una volta al giorno o al mese.
|
||||
- Misure reali in `docs/STATE.md`.
|
||||
+22
-3
@@ -32,19 +32,34 @@ Aggiornato alla fine di ogni fase (guida, sezione 18).
|
||||
- `viaferrea-tools simulate` con KPI annuali in CSV (separatore `;`).
|
||||
- 45 test: dati, determinismo, round-trip dei salvataggi, invarianti di merci e denaro, limiti dei prezzi, crescita e chiusura delle industrie, città, prestiti, collocazione e distanze della mappa, tempi di generazione.
|
||||
|
||||
### F2 — Rete ferroviaria realistica headless
|
||||
- Tracciato: `TrackGeometry` (raccordi al raggio minimo della classe), `TrackPlanner` (profilo a 25 m, inviluppi di pendenza in avanti e all'indietro, smussatura, rilevati, trincee, ponti e gallerie, ponte obbligatorio su acqua, palude e binari altrui, campate per classe di fiume, limiti per era, costi, giorni di cantiere, esproprio), `viaferrea-tools profile` con CSV.
|
||||
- Rete: `RailNetwork` con agganci e scambi, stazioni con bacino, depositi, segnali, cantieri con squadre per livello, rinnovi e ammodernamenti, usura e manutenzione del binario, ispezioni e invecchiamento di ponti e gallerie (ADR 0007).
|
||||
- Treni: acquisto e vendita di veicoli, composizioni, linee con ordini (carica, scarica, attendi il pieno con tempo massimo), A* con vincolo di svolta, blocchi e versi fino al punto sicuro, fisica con aderenza e `Stalled`, soste proporzionali alle unità movimentate.
|
||||
- Pacchetti e linee: `LineGraph` per compagnia con maschere dei carichi, capacità e durata dei giri; ritiro della produzione verso la destinazione migliore, trasbordi, consegna in attesa del consumatore, tariffe merci e passeggeri, costi di esercizio (ADR 0008).
|
||||
- Pendolarismo su rotaia: abbinamento mensile entro 60/90 minuti con i tratti a piedi, quote proporzionali ai lavoratori liberi, capacità residua delle linee, pacchetti giornalieri di andata e ritorno, coperture, scioglimento dei contratti e insoddisfazione «lavoro».
|
||||
- Salvataggi: tutto lo stato ferroviario (rete, cantieri, veicoli, treni in movimento, linee, pacchetti, contratti) entra nel salvataggio e nell'hash.
|
||||
- Scenario `tests/ViaFerrea.Tests/scenarios/valdoria.json` e test di accettazione: tracciato diretto rifiutato per `gMax`; valico con trincea e ponte accettato a 2,5 volte il costo in piano e 180 giorni di cantiere; con tre linee (merci, lavoratori, personale) l'acciaieria passa dal 20 % a oltre l'80 % di media mensile in tre mesi, senza stalli.
|
||||
- `viaferrea-tools bench --trains 2000`: rete di 300 linee a doppio binario costruita con i comandi.
|
||||
- 75 test (dati, mappa, economia, persistenza, pianificatore, rete, treni, incroci senza stallo, `Stalled`, salvataggio con treni in moto, pendolarismo, scenario Valdoria).
|
||||
|
||||
## In corso
|
||||
|
||||
- F2 — Rete ferroviaria realistica headless.
|
||||
- Nessun lavoro a metà: F2 chiusa.
|
||||
|
||||
## Prossimo passo
|
||||
|
||||
- F2.5: `TrackPlanner` (profilo a 25 m, due passate di pendenza, smussatura, classificazione delle opere, costi e tempi, vincoli per era), cantieri con squadre, classi di binario, usura del binario, ponti e gallerie con condizione; `viaferrea-tools profile`.
|
||||
- F3: protocollo completo con test di round-trip di ogni messaggio, server (GameLoop, sessioni WebSocket, API HTTP, autosave, `/metrics`), file Docker, client Godot minimo (connessione, mappa con terreno e opere, strumento binari con profilo, stazioni, depositi, treni, linee, HUD, velocità).
|
||||
|
||||
## Limiti noti
|
||||
|
||||
- Le immagini di riferimento 06–09 (pannelli a tutto schermo e schermata di connessione) non sono state fornite: i pannelli seguiranno palette e componenti dell'immagine 05 finché non arrivano.
|
||||
- Godot non è eseguibile nell'ambiente cloud: il client potrà essere compilato con `Godot.NET.Sdk` ma non avviato né esportato qui.
|
||||
- Senza vettori (F2) il mondo è in lento declino: le città perdono circa l'1 % di abitanti l'anno e le industrie lavorano a circa il 15–30 % (voluto, ADR 0004).
|
||||
- Senza vettori il mondo è in lento declino: le città perdono circa l'1 % di abitanti l'anno e le industrie lavorano a circa il 15–30 % (voluto, ADR 0004).
|
||||
- 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.
|
||||
- La lunghezza dei marciapiedi non è modellata; i segnali sono solo a blocco fisso (niente segnali di percorso).
|
||||
- I depositi non hanno ancora posti per personale né officine (F4); le convenzioni (`CommuteAgreement`) e il Registro degli impieghi arrivano in F4.
|
||||
- Comandi ancora `NotImplemented`: riserve, politiche di manutenzione, interventi, ricambi, convenzioni, commercio, industrie, borsa, concessioni, contratti, ricerca, regioni (fasi F4–F7).
|
||||
- La manutenzione degli impianti (sezione 11) arriva in F5: fino ad allora la condizione delle industrie resta 100.
|
||||
|
||||
## Misure di prestazione
|
||||
@@ -55,3 +70,7 @@ Aggiornato alla fine di ogni fase (guida, sezione 18).
|
||||
| Generazione mappa 64 / 128 / 256 km | 0,8 / 1,4 / 5,6 s | F1 |
|
||||
| `simulate --years 20` su 128 km (110 industrie, 26 città) | 1,7 s (+1,4 s di creazione) | F1 |
|
||||
| Suite di test (45, parallela su 4 core) | ~10 s | F1 |
|
||||
| Suite di test (75, parallela su 4 core) | ~11 s | F2 |
|
||||
| Scenario Valdoria, 24 mesi con tre linee | 2,3 s | F2 |
|
||||
| `bench --trains 2000` (256 km, 600 stazioni, 300 linee, 2.280 km di binario, 2.089 segnali) | tick medio 0,84 ms, p95 0,92, p99 1,21, massimo 10,5 (cambio di giorno); `TrainSystem` 0,79 ms | F2 |
|
||||
| Allocazioni nel tick ordinario con 2.000 treni | < 1 KB (crescita delle liste), nessuna raccolta gen0 in 1.200 tick | F2 |
|
||||
@@ -14,7 +14,7 @@ La guida (6.3) fissa le formule ma lascia aperti alcuni punti: come si somma la
|
||||
4. **Contabilità a partita doppia.** Ogni movimento è un trasferimento tra conti (compagnie, industrie, conto Esterno). Il ritiro di merce paga il produttore al prezzo globale; la consegna a un'industria la addebita al prezzo globale (gli hub usano Pg ± dazio). Con i prezzi locali il margine di ogni trasformatore sarebbe negativo per costruzione (compra a 1,35·Pg, vende a 0,65·Pg). Le famiglie e il mercato mondiale sono il conto Esterno. La somma dei saldi è sempre zero. Le scorte iniziali e quelle create dai test sono contabilizzate come prodotte.
|
||||
5. **Lavoro in sede.** Il 30 % dei posti di ogni industria è coperto da chi vive in sede (villaggio operaio): l'efficienza di un'industria isolata parte da circa 0,3 e cresce solo con i pendolari. È il punto di partenza dell'accettazione F2 («dall'acciaieria sotto il 40 %…»).
|
||||
6. **Trasporto locale su strada.** Produttori, consumatori e hub entro 3 km si scambiano piccole quantità (25 % della giacenza, al massimo 6 unità al giorno per bene), senza vettore. I lavoratori vanno a piedi entro 1,5 km dal bordo della città. Tiene vivo il territorio senza rendere superflua la ferrovia; si spegne da `balance.json`.
|
||||
7. **Crescita solo per le industrie servite.** Il punteggio trimestrale si calcola sempre, ma livello, regressione e chiusura si applicano solo alle industrie servite almeno un giorno nel trimestre (`LastServedDay`: nel bacino di una stazione che è fermata di una linea con treni). Senza questa regola, all'inizio della partita quasi tutte le industrie chiuderebbero entro due anni perché nessuno le serve ancora.
|
||||
7. **Crescita solo per le industrie servite.** Il punteggio trimestrale si calcola sempre, ma livello, regressione e chiusura si applicano solo alle industrie servite almeno un giorno nel trimestre (`LastServedDay`: dal F2 il giorno in cui un vettore ha ritirato o consegnato merce, ADR 0008). Senza questa regola, all'inizio della partita quasi tutte le industrie chiuderebbero entro due anni perché nessuno le serve ancora.
|
||||
8. **Domanda insoddisfatta = capacità mancante.** Un bene è «insoddisfatto» quando la domanda media supera di 1,25 volte la capacità installata (non la produzione effettiva): nascono nuove industrie dove manca capacità, non dove manca il trasporto. Al massimo due nascite all'anno.
|
||||
9. **Servizi cittadini.** I «servizi» di una città sono uno ogni 6.000 abitanti (scuole, ospedali) più le categorie di consumo (alimentari, merci, combustibili, edilizia) con soddisfazione ≥ 0,5: il personale qualificato (città ≥ 5.000 abitanti e servizi ≥ 2) esiste nelle città grandi o in quelle medie ben rifornite.
|
||||
10. **Distanze dalle città** si misurano dal bordo dell'abitato (distanza dal centro meno il raggio), sia nella generazione sia nel gioco.
|
||||
|
||||
@@ -0,0 +1,55 @@
|
||||
# ADR 0007 — Rete ferroviaria, cantieri e circolazione (F2)
|
||||
|
||||
Stato: accettato (F2).
|
||||
|
||||
## Contesto
|
||||
|
||||
La guida (sezione 8) descrive tracciato, opere, cantieri, usura e marcia dei treni, ma lascia aperti
|
||||
il modo di agganciare i binari tra loro, la regola che evita gli stalli su binario semplice, quando
|
||||
si liberano le risorse e cosa succede a un gestore in bancarotta.
|
||||
|
||||
## Decisione
|
||||
|
||||
1. **Pianificatore.** Linea d'asse campionata ogni 25 m con raccordi circolari al raggio minimo
|
||||
della classe; le «due passate» della guida sono gli inviluppi lipschitziani in avanti e
|
||||
all'indietro (massimo e minimo) a pendenza `gMax`, con i vincoli di franco (ponti, attraversamenti)
|
||||
e di quota minima (niente gallerie se vietate) come limiti inferiori; poi smussatura su 5 campioni
|
||||
e classificazione in rilevato, trincea, ponte e galleria. Ponte obbligatorio su acqua, palude e
|
||||
binari altrui (cavalcavia automatico); i binari propri non si attraversano a raso: si collegano
|
||||
alle estremità. Campata del fiume dalla larghezza della sua classe (`riverWidthMByClass`), di laghi
|
||||
e mare dalla lunghezza della traversata; limiti di galleria e ponte per era.
|
||||
2. **Aggancio.** Un'estremità entro `snapM` (60 m) da un nodo della compagnia vi si aggancia; se cade
|
||||
sul tracciato di un arco proprio (anche in cantiere) lo divide in uno scambio, misurando la
|
||||
distanza dai segmenti e non solo dai campioni. Stazioni e depositi si agganciano allo stesso modo
|
||||
o nascono come nodo isolato. Le liste della rete non si compattano mai: le entità rimosse restano
|
||||
marcate, gli id restano stabili.
|
||||
3. **Cantieri.** Una squadra per progetto, numero di squadre dal livello della compagnia; le opere si
|
||||
eseguono in ordine con i metri al giorno del tipo di opera; gli archi restano `UnderConstruction`
|
||||
finché il progetto non è completo. Il secondo tronco di un arco diviso durante il cantiere entra
|
||||
nello stesso progetto.
|
||||
4. **Segnalamento a blocchi.** Ogni arco ha sezioni di blocco tra i segnali, per verso. Un treno
|
||||
prenota davanti a sé le sezioni che gli servono per fermarsi (spazio di frenata più
|
||||
`lookaheadMarginM`). Sul binario semplice prenota anche il **verso** di tutti gli archi successivi
|
||||
fino al primo **punto sicuro**: stazione con un binario libero (che resta prenotato), deposito,
|
||||
doppio binario o destinazione. Due treni non possono quindi impegnare in versi opposti lo stesso
|
||||
tratto senza un punto d'incrocio: è la regola che rende la rete priva di stalli faccia a faccia.
|
||||
Gli stalli restanti (cicli di attese) vengono segnalati dopo `waitWarningDays` come «possibile
|
||||
stallo della rete».
|
||||
5. **Rilascio.** Blocchi, versi e binari di stazione si liberano quando la coda del treno li ha
|
||||
superati (odometro − punto di uscita ≥ lunghezza del treno). I binari di stazione sono lunghi
|
||||
quanto serve: la lunghezza dei marciapiedi non è modellata in F2.
|
||||
6. **Svolte.** A* sugli archi orientati con angolo massimo di svolta 100° agli scambi; in stazione, in
|
||||
deposito e ai binari morti il treno può invertire la marcia.
|
||||
7. **Fisica.** `a = (Ft − R)/m`, `Ft = min(P/v, TE, aderenza × fattore × massa delle locomotive × g)`,
|
||||
`R = m·g·(attrito + pendenza) + 0,6·v²·cx`; frenata costante. Un treno sotto 1 km/h in salita per
|
||||
120 s diventa `Stalled` con avviso; i passeggeri pesano 80 kg ciascuno.
|
||||
8. **Usura e manutenzione del binario.** Usura giornaliera = tonnellate·fattori / `k`; la manutenzione
|
||||
ordinaria costa per km e giorno. Un gestore con cassa negativa non paga: il binario perde
|
||||
condizione invece di essere mantenuto. Ponti e gallerie oltre la vita utile perdono la condizione
|
||||
in `agingYearsToZero` anni; sotto `closeBelow` il treno passa a velocità minima.
|
||||
|
||||
## Conseguenze
|
||||
|
||||
- Le linee a binario semplice funzionano senza segnali intermedi purché le stazioni abbiano un
|
||||
binario libero per l'incrocio; i segnali servono solo ad aumentare la capacità.
|
||||
- `viaferrea-tools bench` misura la circolazione con 2.000 treni su 300 linee a doppio binario.
|
||||
@@ -0,0 +1,59 @@
|
||||
# ADR 0008 — Pacchetti, grafo delle linee e pendolarismo su rotaia (F2)
|
||||
|
||||
Stato: accettato (F2).
|
||||
|
||||
## Contesto
|
||||
|
||||
La guida (sezioni 7 e 9) definisce pacchetti di merci e passeggeri, il `LineGraph`, i contratti di
|
||||
pendolarismo e le coperture, ma non dice come si sceglie la destinazione delle merci, quali linee
|
||||
possono portare un carico, come si stima la capacità di una linea né chi conta come «servito».
|
||||
|
||||
## Decisione
|
||||
|
||||
1. **Orologio dei treni.** Un tick vale 3 s di orologio dei treni (fattore 60 della guida): un giorno
|
||||
di calendario è di 12 minuti di orologio. Tempi di viaggio, attese massime e contratti si misurano
|
||||
in minuti di orologio dei treni.
|
||||
2. **Grafo delle linee.** Per compagnia: nodi = stazioni, archi = fermate consecutive con il tempo
|
||||
stimato (percorso A* alla velocità del treno più lento × `lineRunTimeMargin` + sosta). La sosta
|
||||
stimata è quella di scarico e carico completi del treno più capiente (unità / ritmo di carico),
|
||||
almeno `minDwellMinutes`. Dijkstra sugli stati (stazione, linea) con penalità di cambio pari a due
|
||||
soste minime.
|
||||
3. **Carichi ammessi.** Ogni linea ha la maschera dei carichi dei suoi treni: un bit per bene
|
||||
trasportabile dai suoi carri, uno per i lavoratori, uno per il personale. Il percorso di un
|
||||
pacchetto usa solo linee che lo possono portare (al più 62 beni, verificato dal validatore). Una
|
||||
linea senza treni non porta nulla.
|
||||
4. **Pacchetti merci.** Ogni giorno le industrie nel bacino di una stazione di carico affidano la
|
||||
produzione alla stazione se esiste una destinazione raggiungibile con un consumatore; si sceglie
|
||||
quella con il bisogno più alto (spazio in magazzino, domanda delle città, capacità degli hub,
|
||||
meno le merci già in arrivo), pesato per `1/(1 + ore di viaggio)`. Il produttore è pagato al ritiro
|
||||
al prezzo globale; il vettore incassa la tariffa alla consegna; il consumatore paga al prezzo
|
||||
globale. Una merce che arriva quando il consumatore è pieno resta in stazione «in attesa del
|
||||
consumatore» fino alla scadenza. Il trasbordo ricalcola il tratto successivo.
|
||||
5. **Servita.** Un'industria è servita nel giorno in cui il vettore le ritira merce o gliene consegna
|
||||
(sostituisce la regola F1 «nel bacino di una stazione con treni»): una stazione solo passeggeri non
|
||||
fa crescere né regredire le industrie vicine.
|
||||
6. **Capacità di una linea.** Posti al giorno = posti dei treni × giri al giorno (minuti di orologio
|
||||
del giorno / durata stimata del giro). L'abbinamento ne assegna al più `lineCapacityUtilization`
|
||||
(85 %), per assorbire ritardi, incroci e soste reali.
|
||||
7. **Abbinamento mensile.** Per ogni posto scoperto (posti − quota in sede, con la parte frazionaria
|
||||
arrotondata per eccesso) si cercano coppie (stazione di casa, stazione di lavoro) della stessa
|
||||
compagnia con un collegamento per la classe giusta, entro 60 minuti per i lavoratori e 90 per il
|
||||
personale compresi i tratti a piedi (dal bordo della città alla stazione e dalla stazione
|
||||
all'industria, a 4,5 km/h). I candidati si ordinano per tempo; una prima passata assegna a ogni città
|
||||
una quota proporzionale ai suoi lavoratori liberi, una seconda distribuisce il resto in ordine di
|
||||
tempo; mai oltre la capacità residua di ogni linea del percorso.
|
||||
8. **Coperture.** Ogni giorno un contratto genera un pacchetto di andata (scadenza `boardDays`); il
|
||||
ritorno nasce all'arrivo. Copertura = EMA su 30 giorni di consegnati/addetti, **non troncata a 1**:
|
||||
i treni arrivano a ondate e un giorno con due treni compensa uno senza. Le presenze dell'industria
|
||||
usano `min(1, copertura)`. Un contratto nuovo parte da `railStartCoverage` (0,5). Copertura sotto
|
||||
0,5 per 90 giorni o percorso scomparso → il contratto si scioglie, i lavoratori tornano liberi e la
|
||||
città accumula insoddisfazione «lavoro», che si riassorbe in `workDissatisfactionDecayDays`.
|
||||
9. **Scenario di accettazione.** In `valdoria.json` le miniere partono ai livelli 4 e 3 (lavorano con
|
||||
il solo personale in sede, circa il 36 %) per fornire abbastanza minerale e carbone all'acciaieria;
|
||||
la linea merci prosegue fino a Valdoria, dove la fabbrica di attrezzi compra acciaio e carbone.
|
||||
|
||||
## Conseguenze
|
||||
|
||||
- Con la stima prudente della capacità le coperture superano 0,9 entro due mesi (test di 14.5).
|
||||
- La crescita trimestrale della guida è rapida: un'acciaieria ben servita sale di livello ogni due
|
||||
trimestri e chiede più pendolari; il giocatore deve aggiungere carrozze e treni.
|
||||
@@ -141,6 +141,8 @@ public sealed class TownGenParams
|
||||
public required int MinPopulation { get; init; }
|
||||
public required double RadiusBaseCells { get; init; }
|
||||
public required double RadiusPerSqrtPop { get; init; }
|
||||
/// <summary>Crescita minima del raggio (celle) prima di allargare l'abitato.</summary>
|
||||
public required double RadiusHysteresisCells { get; init; }
|
||||
}
|
||||
|
||||
public sealed class IndustryGenParams
|
||||
@@ -185,6 +187,8 @@ public sealed class WorldMarketParams
|
||||
public required double ShockMin { get; init; }
|
||||
public required double ShockMax { get; init; }
|
||||
public required double ShockDecayDays { get; init; }
|
||||
/// <summary>Minimo della componente mondiale del prezzo, come frazione del prezzo base.</summary>
|
||||
public required double PriceFloor { get; init; }
|
||||
}
|
||||
|
||||
public sealed class LocalPriceBalance
|
||||
@@ -229,6 +233,12 @@ public sealed class GrowthBalance
|
||||
|
||||
public sealed class TownBalance
|
||||
{
|
||||
/// <summary>Giorni in cui l'insoddisfazione «lavoro» si riduce di un fattore e.</summary>
|
||||
public required int WorkDissatisfactionDecayDays { get; init; }
|
||||
public required double DemandPriceFactorMin { get; init; }
|
||||
public required double DemandPriceFactorMax { get; init; }
|
||||
/// <summary>Soglia di popolazione annunciata nella cronaca.</summary>
|
||||
public required int PopulationMilestone { get; init; }
|
||||
public required double BaseGrowth { get; init; }
|
||||
public required double SatisfactionWeight { get; init; }
|
||||
public required double EmploymentWeight { get; init; }
|
||||
@@ -272,6 +282,8 @@ public sealed class EmploymentBalance
|
||||
public required int ReturnBoardDays { get; init; }
|
||||
/// <summary>Copertura iniziale di un contratto su rotaia appena creato.</summary>
|
||||
public required double RailStartCoverage { get; init; }
|
||||
/// <summary>Quota della capacità stimata delle linee assegnabile ai contratti (margine per ritardi e soste).</summary>
|
||||
public required double LineCapacityUtilization { get; init; }
|
||||
}
|
||||
|
||||
public sealed class LocalTransportBalance
|
||||
|
||||
@@ -46,6 +46,10 @@ public sealed class OperationsParams
|
||||
public required double LookaheadMarginM { get; init; }
|
||||
public required int WaitWarningDays { get; init; }
|
||||
public required int DefaultMaxWaitDays { get; init; }
|
||||
/// <summary>Margine sui tempi di percorrenza stimati delle linee (accelerazioni e frenate).</summary>
|
||||
public required double LineRunTimeMargin { get; init; }
|
||||
/// <summary>Velocità assunta per stimare i tempi di una linea ancora senza treni.</summary>
|
||||
public required double DefaultLineSpeedKmh { get; init; }
|
||||
}
|
||||
|
||||
public sealed class ProfileParams
|
||||
@@ -154,6 +158,10 @@ public sealed class StructureParams
|
||||
public required double SpeedLimitBelow { get; init; }
|
||||
public required double SpeedLimitFactor { get; init; }
|
||||
public required double CloseBelow { get; init; }
|
||||
/// <summary>Fattore di velocità sulle opere sotto la soglia di chiusura.</summary>
|
||||
public required double ClosedSpeedFactor { get; init; }
|
||||
/// <summary>Anni in cui un'opera oltre la vita utile perde tutta la condizione.</summary>
|
||||
public required double AgingYearsToZero { get; init; }
|
||||
}
|
||||
|
||||
public sealed class PhysicsParams
|
||||
@@ -167,4 +175,6 @@ public sealed class PhysicsParams
|
||||
public required double BrakingMs2 { get; init; }
|
||||
public required double StallSpeedKmh { get; init; }
|
||||
public required double StallSeconds { get; init; }
|
||||
/// <summary>Massa di un passeggero con bagaglio (t).</summary>
|
||||
public required double PassengerMassT { get; init; }
|
||||
}
|
||||
@@ -17,6 +17,7 @@ public static class DataValidator
|
||||
|
||||
// --- beni
|
||||
Unique("goods.json", d.Goods.Select(g => g.Id), errors);
|
||||
if (d.Goods.Count > Rail.LineGraph.MaxGoods) Err("goods.json", $"al massimo {Rail.LineGraph.MaxGoods} beni (maschera dei carichi delle linee)");
|
||||
var goodIds = d.Goods.Select(g => g.Id).ToHashSet(StringComparer.Ordinal);
|
||||
foreach (string required in new[] { "spare_parts", "machinery" })
|
||||
{
|
||||
|
||||
@@ -14,16 +14,38 @@ public sealed record Connection(StationId Destination, double Minutes, Hop[] Hop
|
||||
/// <summary>
|
||||
/// Grafo delle linee di una compagnia (guida 7, 9): nodi = stazioni, archi = fermate
|
||||
/// consecutive di una linea con il tempo di percorrenza stimato. Dijkstra sugli stati
|
||||
/// (stazione, linea) con penalità di cambio. Ricostruito quando cambiano rete, linee o treni.
|
||||
/// (stazione, linea) con penalità di cambio, limitato alle linee i cui treni possono portare
|
||||
/// il carico richiesto (merce con carri adatti, lavoratori o personale con le carrozze della
|
||||
/// classe). Ricostruito quando cambiano rete, linee o treni.
|
||||
/// </summary>
|
||||
public sealed class LineGraph
|
||||
{
|
||||
private readonly record struct Segment(int From, int To, LineId Line, double Minutes);
|
||||
private readonly record struct Segment(int From, int To, LineId Line, double Minutes, ulong Carries);
|
||||
|
||||
private readonly Dictionary<int, List<Segment>> _out = new();
|
||||
private readonly Dictionary<int, Dictionary<int, Connection>> _reach = new();
|
||||
private readonly Dictionary<(int, ulong), Dictionary<int, Connection>> _reach = new();
|
||||
private readonly double _transferMinutes;
|
||||
|
||||
/// <summary>Bit del carico «lavoratori» (i bit bassi sono i beni, uno per indice).</summary>
|
||||
public const ulong WorkersCargo = 1UL << 62;
|
||||
/// <summary>Bit del carico «personale qualificato».</summary>
|
||||
public const ulong StaffCargo = 1UL << 63;
|
||||
/// <summary>Numero massimo di beni rappresentabili nella maschera dei carichi.</summary>
|
||||
public const int MaxGoods = 62;
|
||||
|
||||
public static ulong GoodCargo(int good) => 1UL << good;
|
||||
public static ulong PaxCargo(Data.PaxClass cls) => cls == Data.PaxClass.Staff ? StaffCargo : WorkersCargo;
|
||||
|
||||
public static ulong CargoOf(in Packet p) => p.Kind switch
|
||||
{
|
||||
PacketKind.Freight => GoodCargo(p.Good),
|
||||
PacketKind.Staff => StaffCargo,
|
||||
_ => WorkersCargo,
|
||||
};
|
||||
|
||||
/// <summary>Carichi che i treni di ogni linea possono portare.</summary>
|
||||
public Dictionary<int, ulong> Carries { get; } = new();
|
||||
|
||||
public CompanyId Company { get; }
|
||||
public int Version { get; }
|
||||
|
||||
@@ -38,16 +60,41 @@ public sealed class LineGraph
|
||||
Company = company;
|
||||
Version = version;
|
||||
var ops = w.Data.Construction.Operations;
|
||||
double dwell = w.Data.Construction.Stations.MinDwellMinutes;
|
||||
_transferMinutes = dwell * 2;
|
||||
var sp = w.Data.Construction.Stations;
|
||||
_transferMinutes = sp.MinDwellMinutes * 2;
|
||||
var net = w.Network;
|
||||
var path = new List<RouteStep>();
|
||||
foreach (var line in w.Lines)
|
||||
{
|
||||
if (line.Removed || line.Owner != company || line.Stops.Count < 2) continue;
|
||||
var trains = w.Trains.Where(t => !t.Removed && t.Line == line.Id).ToList();
|
||||
double speed = trains.Count > 0 ? trains.Min(t => t.MaxSpeedKmh) : 60;
|
||||
double speed = trains.Count > 0 ? trains.Min(t => t.MaxSpeedKmh) : ops.DefaultLineSpeedKmh;
|
||||
bool electric = trains.Any(t => t.NeedsElectrification);
|
||||
ulong carries = 0;
|
||||
foreach (var t in trains)
|
||||
{
|
||||
foreach (var vid in t.Vehicles)
|
||||
{
|
||||
var def = w.Vehicles[vid.Value].Def;
|
||||
if (def.Kind == Data.VehicleKind.Coach) carries |= PaxCargo(def.Class ?? Data.PaxClass.Worker);
|
||||
else if (def.Kind == Data.VehicleKind.Wagon)
|
||||
foreach (int g in def.GoodIndices) carries |= GoodCargo(g);
|
||||
}
|
||||
}
|
||||
Carries[line.Id.Value] = carries;
|
||||
// sosta stimata a ogni fermata: scarico e carico completi del treno più capiente
|
||||
double dwell = sp.MinDwellMinutes;
|
||||
foreach (var t in trains)
|
||||
{
|
||||
double units = 0, perMinute = 0;
|
||||
foreach (var vid in t.Vehicles)
|
||||
{
|
||||
var def = w.Vehicles[vid.Value].Def;
|
||||
if (def.Kind == Data.VehicleKind.Coach) { units += def.PaxCapacity ?? 0; perMinute += sp.PaxPerMinutePerCoach; }
|
||||
else if (def.Kind == Data.VehicleKind.Wagon) { units += def.Capacity ?? 0; perMinute += sp.FreightUnitsPerMinutePerWagon; }
|
||||
}
|
||||
if (perMinute > 0) dwell = Math.Max(dwell, 2 * units / perMinute);
|
||||
}
|
||||
double cycle = 0;
|
||||
bool complete = true;
|
||||
for (int i = 0; i < line.Stops.Count; i++)
|
||||
@@ -62,10 +109,10 @@ public sealed class LineGraph
|
||||
}
|
||||
double seconds = 0;
|
||||
foreach (var step in path) seconds += Pathfinder.EdgeTime(net.Edges[step.Edge.Value], speed / 3.6);
|
||||
double minutes = seconds / 60 * 1.15 + dwell; // margine per accelerazioni e frenate
|
||||
double minutes = seconds / 60 * ops.LineRunTimeMargin + dwell;
|
||||
cycle += minutes;
|
||||
if (!_out.TryGetValue(a.Id.Value, out var list)) _out[a.Id.Value] = list = [];
|
||||
list.Add(new Segment(a.Id.Value, b.Id.Value, line.Id, minutes));
|
||||
list.Add(new Segment(a.Id.Value, b.Id.Value, line.Id, minutes, carries));
|
||||
}
|
||||
if (!complete || cycle <= 0) continue;
|
||||
CycleMinutes[line.Id.Value] = cycle;
|
||||
@@ -89,10 +136,13 @@ public sealed class LineGraph
|
||||
foreach (var list in _out.Values) list.Sort((x, y) => x.To != y.To ? x.To.CompareTo(y.To) : x.Line.Value.CompareTo(y.Line.Value));
|
||||
}
|
||||
|
||||
/// <summary>Collegamenti migliori da una stazione verso tutte le stazioni raggiungibili.</summary>
|
||||
public IReadOnlyDictionary<int, Connection> From(StationId origin)
|
||||
/// <summary>
|
||||
/// Collegamenti migliori da una stazione verso tutte le stazioni raggiungibili con linee i cui
|
||||
/// treni portano il carico indicato (maschera: beni, <see cref="WorkersCargo"/>, <see cref="StaffCargo"/>).
|
||||
/// </summary>
|
||||
public IReadOnlyDictionary<int, Connection> From(StationId origin, ulong cargo)
|
||||
{
|
||||
if (_reach.TryGetValue(origin.Value, out var cached)) return cached;
|
||||
if (_reach.TryGetValue((origin.Value, cargo), out var cached)) return cached;
|
||||
var result = new Dictionary<int, Connection>();
|
||||
// stato = (stazione, linea su cui si viaggia); linea −1 = a terra all'origine
|
||||
var best = new Dictionary<(int, int), double>();
|
||||
@@ -109,6 +159,7 @@ public sealed class LineGraph
|
||||
if (!_out.TryGetValue(state.Station, out var segs)) continue;
|
||||
foreach (var seg in segs)
|
||||
{
|
||||
if ((seg.Carries & cargo) == 0) continue;
|
||||
double c = cost + seg.Minutes + (state.Line >= 0 && state.Line != seg.Line.Value ? _transferMinutes : 0);
|
||||
var next = (seg.To, seg.Line.Value);
|
||||
if (best.TryGetValue(next, out double old) && old <= c) continue;
|
||||
@@ -117,7 +168,7 @@ public sealed class LineGraph
|
||||
open.Enqueue(next, (c, seg.To, seg.Line.Value));
|
||||
}
|
||||
}
|
||||
_reach[origin.Value] = result;
|
||||
_reach[(origin.Value, cargo)] = result;
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
@@ -20,6 +20,9 @@ public sealed class SystemPipeline(IReadOnlyList<ISimSystem> systems)
|
||||
/// <summary>Tick totali (Stopwatch) spesi per sistema quando Profile è attivo.</summary>
|
||||
public long[] ElapsedTicks { get; } = new long[systems.Count];
|
||||
|
||||
/// <summary>Byte allocati per sistema quando Profile è attivo.</summary>
|
||||
public long[] AllocatedBytes { get; } = new long[systems.Count];
|
||||
|
||||
public static SystemPipeline CreateDefault() => new(
|
||||
[
|
||||
new ClockSystem(),
|
||||
@@ -46,9 +49,11 @@ public sealed class SystemPipeline(IReadOnlyList<ISimSystem> systems)
|
||||
}
|
||||
for (int i = 0; i < Systems.Count; i++)
|
||||
{
|
||||
long bytes = GC.GetAllocatedBytesForCurrentThread();
|
||||
long start = Stopwatch.GetTimestamp();
|
||||
Systems[i].Step(ctx);
|
||||
ElapsedTicks[i] += Stopwatch.GetTimestamp() - start;
|
||||
AllocatedBytes[i] += GC.GetAllocatedBytesForCurrentThread() - bytes;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -58,6 +58,20 @@ public sealed class ConstructionSystem : ISimSystem
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Completa subito tutti i cantieri aperti. Solo per gli strumenti (banco di prova, collaudi):
|
||||
/// in partita i cantieri avanzano con le squadre.
|
||||
/// </summary>
|
||||
public static void CompleteAllNow(World w)
|
||||
{
|
||||
foreach (var p in w.Network.Projects)
|
||||
{
|
||||
if (p.Done) continue;
|
||||
p.ProgressDays = p.TotalDays;
|
||||
Complete(w.Context, w, p);
|
||||
}
|
||||
}
|
||||
|
||||
private static int FreeCrew(RailNetwork net, CompanyId company, int crews)
|
||||
{
|
||||
for (int c = 0; c < crews; c++)
|
||||
@@ -172,7 +186,7 @@ public sealed class ConstructionSystem : ISimSystem
|
||||
double age = (ctx.Day - e.LastRenewalDay) / (double)daysPerYear;
|
||||
double structureBefore = e.StructureCondition;
|
||||
if (ctx.Day - e.LastInspectionDay > st.InspectionIntervalDays) e.StructureCondition -= st.MissedInspectionWearPerDay;
|
||||
if (age > st.RenewalYears) e.StructureCondition -= 100.0 / (10.0 * daysPerYear);
|
||||
if (age > st.RenewalYears) e.StructureCondition -= 100.0 / (st.AgingYearsToZero * daysPerYear);
|
||||
e.StructureCondition = Math.Max(0, e.StructureCondition);
|
||||
if (structureBefore >= st.CloseBelow && e.StructureCondition < st.CloseBelow)
|
||||
w.Events.Add(new GameEvent(ctx.Day, EventKind.Maintenance, EventSeverity.Critical,
|
||||
@@ -187,7 +201,7 @@ public sealed class ConstructionSystem : ISimSystem
|
||||
var st = w.Data.Construction.Structures;
|
||||
double f = e.Condition < 30 ? tw.LimitBelow30 : e.Condition < 60 ? tw.LimitBelow60 : 1.0;
|
||||
if (e.StructureCondition < st.SpeedLimitBelow) f = Math.Min(f, st.SpeedLimitFactor);
|
||||
if (e.StructureCondition < st.CloseBelow) f = Math.Min(f, 0.1);
|
||||
if (e.StructureCondition < st.CloseBelow) f = Math.Min(f, st.ClosedSpeedFactor);
|
||||
return f;
|
||||
}
|
||||
}
|
||||
@@ -56,7 +56,8 @@ public sealed class DemandSystem : ISimSystem
|
||||
var def = w.Data.Goods[good];
|
||||
if (def.Town is not { } td || def.Era > year || (td.UntilYear is { } until && year >= until)) return 0;
|
||||
double ratio = w.Market.GlobalPrice[good] / def.BasePrice;
|
||||
double priceFactor = DMath.Clamp(DMath.Pow(ratio, -def.Elasticity), 0.5, 1.5);
|
||||
var tb = w.Data.Balance.Town;
|
||||
double priceFactor = DMath.Clamp(DMath.Pow(ratio, -def.Elasticity), tb.DemandPriceFactorMin, tb.DemandPriceFactorMax);
|
||||
return town.Population / 1000.0 * td.DemandPerThousand * priceFactor;
|
||||
}
|
||||
}
|
||||
@@ -1,14 +1,16 @@
|
||||
using ViaFerrea.Core.Common;
|
||||
using ViaFerrea.Core.Data;
|
||||
using ViaFerrea.Core.Economy;
|
||||
using ViaFerrea.Core.Rail;
|
||||
|
||||
namespace ViaFerrea.Core.Simulation.Systems;
|
||||
|
||||
/// <summary>
|
||||
/// Pendolarismo (guida, sezione 9). In F1 gestisce i servizi cittadini, i lavoratori in sede e i
|
||||
/// contratti a piedi verso posti di lavoro entro il raggio pedonale; i contratti su rotaia
|
||||
/// arrivano in F4 con il LineGraph. Ogni mese ricostruisce i contratti a piedi; ogni giorno
|
||||
/// aggiorna presenze e coperture.
|
||||
/// Pendolarismo (guida, sezione 9): servizi cittadini, lavoratori in sede, contratti a piedi entro
|
||||
/// il raggio pedonale e contratti su rotaia sul grafo delle linee (entro 60 minuti di orologio dei
|
||||
/// treni per i lavoratori, 90 per il personale, tratto a piedi compreso). Ogni mese ricostruisce i
|
||||
/// contratti a piedi, verifica quelli su rotaia e ne crea di nuovi; ogni giorno genera i pacchetti
|
||||
/// di passeggeri e aggiorna presenze e coperture.
|
||||
/// </summary>
|
||||
public sealed class EmploymentSystem : ISimSystem
|
||||
{
|
||||
@@ -17,8 +19,9 @@ public sealed class EmploymentSystem : ISimSystem
|
||||
public void Step(WorldContext ctx)
|
||||
{
|
||||
if (!ctx.IsNewDay) return;
|
||||
if (ctx.IsNewMonth) Rematch(ctx);
|
||||
UpdatePresence(ctx);
|
||||
if (ctx.IsNewMonth) Rematch(ctx);
|
||||
GeneratePassengers(ctx);
|
||||
}
|
||||
|
||||
/// <summary>Ricostruisce servizi cittadini e contratti a piedi.</summary>
|
||||
@@ -30,6 +33,7 @@ public sealed class EmploymentSystem : ISimSystem
|
||||
var eb = w.Data.Balance.Employment;
|
||||
|
||||
w.Commutes.RemoveAll(c => c.Walking);
|
||||
ValidateRailContracts(ctx);
|
||||
|
||||
foreach (var town in w.Towns)
|
||||
{
|
||||
@@ -72,8 +76,8 @@ public sealed class EmploymentSystem : ISimSystem
|
||||
if (nearby.Count == 0) continue;
|
||||
nearby.Sort((a, b) => a.Km != b.Km ? a.Km.CompareTo(b.Km) : a.Town.Id.Value.CompareTo(b.Town.Id.Value));
|
||||
|
||||
int openWorkers = ind.JobsWorkers - (int)Math.Ceiling(OnSite(ind.JobsWorkers, ib.OnSiteWorkerShare)) - ind.ContractedWorkers;
|
||||
int openStaff = ind.JobsStaff - (int)Math.Ceiling(OnSite(ind.JobsStaff, ib.OnSiteStaffShare)) - ind.ContractedStaff;
|
||||
int openWorkers = OpenJobs(ind.JobsWorkers, ib.OnSiteWorkerShare, ind.ContractedWorkers);
|
||||
int openStaff = OpenJobs(ind.JobsStaff, ib.OnSiteStaffShare, ind.ContractedStaff);
|
||||
foreach (var (km, town) in nearby)
|
||||
{
|
||||
if (openWorkers > 0)
|
||||
@@ -100,6 +104,195 @@ public sealed class EmploymentSystem : ISimSystem
|
||||
}
|
||||
}
|
||||
}
|
||||
MatchRail(ctx);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// I contratti su rotaia restano validi se il percorso esiste ancora e la copertura non è
|
||||
/// rimasta sotto la soglia troppo a lungo; altrimenti si sciolgono e la città se ne lamenta.
|
||||
/// </summary>
|
||||
private static void ValidateRailContracts(WorldContext ctx)
|
||||
{
|
||||
var w = ctx.World;
|
||||
var eb = w.Data.Balance.Employment;
|
||||
var tb = w.Data.Balance.Town;
|
||||
for (int i = w.Commutes.Count - 1; i >= 0; i--)
|
||||
{
|
||||
var c = w.Commutes[i];
|
||||
if (c.Walking) continue;
|
||||
bool routeOk = c.HomeStation.IsValid && c.WorkStation.IsValid
|
||||
&& w.LineGraphs.For(w, c.Carrier).From(c.HomeStation, LineGraph.PaxCargo(c.Category)).ContainsKey(c.WorkStation.Value);
|
||||
bool coverageOk = c.LowCoverageDays < eb.DissolveDays;
|
||||
if (routeOk && coverageOk) continue;
|
||||
w.Commutes.RemoveAt(i);
|
||||
var town = w.Towns[c.Town.Value];
|
||||
town.WorkDissatisfaction = Math.Min(1, town.WorkDissatisfaction + tb.WorkSatisfactionPenalty);
|
||||
w.Events.Add(new GameEvent(ctx.Day, EventKind.Employment, EventSeverity.Warning,
|
||||
$"{c.Headcount} {(c.Category == PaxClass.Staff ? "tecnici" : "lavoratori")} di {town.Name} perdono il posto: " +
|
||||
(routeOk ? "i treni non li portano al lavoro" : "il collegamento non esiste più"), EntityKind.Town, town.Id.Value, c.Carrier));
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Abbinamento su rotaia: per ogni posto scoperto, città con lavoratori liberi raggiungibili
|
||||
/// entro il tempo massimo; in ordine di tempo di viaggio, senza superare la capacità residua
|
||||
/// delle linee del percorso.
|
||||
/// </summary>
|
||||
private static void MatchRail(WorldContext ctx)
|
||||
{
|
||||
var w = ctx.World;
|
||||
var eb = w.Data.Balance.Employment;
|
||||
var tb = w.Data.Balance.Town;
|
||||
var ib = w.Data.Balance.Industry;
|
||||
var net = w.Network;
|
||||
if (w.Lines.Count == 0) return;
|
||||
|
||||
// posti già occupati sulle linee per classe
|
||||
var usedWorkers = new Dictionary<int, double>();
|
||||
var usedStaff = new Dictionary<int, double>();
|
||||
foreach (var c in w.Commutes)
|
||||
{
|
||||
if (c.Walking) continue;
|
||||
var used = c.Category == PaxClass.Staff ? usedStaff : usedWorkers;
|
||||
foreach (var l in c.Route) used[l.Value] = used.GetValueOrDefault(l.Value) + c.Headcount;
|
||||
}
|
||||
|
||||
var candidates = new List<(double Minutes, Town Town, Station Home, Station Work, Connection Conn)>();
|
||||
var quota = new Dictionary<int, int>();
|
||||
foreach (var ind in w.Industries)
|
||||
{
|
||||
if (ind.Closed || ind.Level <= 0) continue;
|
||||
int openWorkers = OpenJobs(ind.JobsWorkers, ib.OnSiteWorkerShare, ind.ContractedWorkers);
|
||||
int openStaff = OpenJobs(ind.JobsStaff, ib.OnSiteStaffShare, ind.ContractedStaff);
|
||||
if (openWorkers <= 0 && openStaff <= 0) continue;
|
||||
foreach (PaxClass cls in new[] { PaxClass.Worker, PaxClass.Staff })
|
||||
{
|
||||
int open = cls == PaxClass.Staff ? openStaff : openWorkers;
|
||||
if (open <= 0) continue;
|
||||
double maxMinutes = cls == PaxClass.Staff ? eb.StaffMaxMinutes : eb.WorkerMaxMinutes;
|
||||
candidates.Clear();
|
||||
foreach (var work in net.Stations)
|
||||
{
|
||||
if (net.Nodes[work.Node.Value].Station != work.Id || !work.Industries.Contains(ind.Id)) continue;
|
||||
var graph = w.LineGraphs.For(w, work.Owner);
|
||||
double walkWork = Vec2.Distance(work.Position, ind.Position) / 1000 / eb.WalkSpeedKmh * 60;
|
||||
foreach (var home in net.Stations)
|
||||
{
|
||||
if (home.Owner != work.Owner || home.Id == work.Id || net.Nodes[home.Node.Value].Station != home.Id) continue;
|
||||
if (!graph.From(home.Id, LineGraph.PaxCargo(cls)).TryGetValue(work.Id.Value, out var conn)) continue;
|
||||
foreach (var tid in home.Towns)
|
||||
{
|
||||
var town = w.Towns[tid.Value];
|
||||
double walkHome = w.TownEdgeDistanceKm(town, home.Position) / eb.WalkSpeedKmh * 60;
|
||||
double minutes = conn.Minutes + walkHome + walkWork;
|
||||
if (minutes <= maxMinutes) candidates.Add((minutes, town, home, work, conn));
|
||||
}
|
||||
}
|
||||
}
|
||||
candidates.Sort((a, b) => a.Minutes != b.Minutes ? a.Minutes.CompareTo(b.Minutes)
|
||||
: a.Town.Id.Value != b.Town.Id.Value ? a.Town.Id.Value.CompareTo(b.Town.Id.Value)
|
||||
: a.Home.Id.Value != b.Home.Id.Value ? a.Home.Id.Value.CompareTo(b.Home.Id.Value)
|
||||
: a.Work.Id.Value.CompareTo(b.Work.Id.Value));
|
||||
// prima passata: quote proporzionali ai lavoratori liberi di ogni città; seconda: il resto
|
||||
// in ordine di tempo di viaggio. Mai oltre la capacità residua delle linee del percorso.
|
||||
quota.Clear();
|
||||
int totalFree = 0;
|
||||
foreach (var cand in candidates)
|
||||
{
|
||||
if (quota.ContainsKey(cand.Town.Id.Value)) continue;
|
||||
int free = cls == PaxClass.Staff ? cand.Town.FreeStaff(tb) : cand.Town.FreeWorkers(tb);
|
||||
quota[cand.Town.Id.Value] = free;
|
||||
totalFree += free;
|
||||
}
|
||||
if (totalFree <= 0) continue;
|
||||
int open0 = open;
|
||||
foreach (var cand in candidates)
|
||||
{
|
||||
int townQuota = (int)Math.Ceiling((double)open0 * quota[cand.Town.Id.Value] / totalFree);
|
||||
open -= Assign(w, ind, cls, cand, Math.Min(open, townQuota), usedWorkers, usedStaff, eb, tb);
|
||||
}
|
||||
foreach (var cand in candidates)
|
||||
{
|
||||
if (open <= 0) break;
|
||||
open -= Assign(w, ind, cls, cand, open, usedWorkers, usedStaff, eb, tb);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>Crea un contratto per al più <paramref name="limit"/> pendolari della città candidata.</summary>
|
||||
private static int Assign(World w, Industry ind, PaxClass cls,
|
||||
(double Minutes, Town Town, Station Home, Station Work, Connection Conn) cand, int limit,
|
||||
Dictionary<int, double> usedWorkers, Dictionary<int, double> usedStaff, EmploymentBalance eb, TownBalance tb)
|
||||
{
|
||||
if (limit <= 0) return 0;
|
||||
int free = cls == PaxClass.Staff ? cand.Town.FreeStaff(tb) : cand.Town.FreeWorkers(tb);
|
||||
var graph = w.LineGraphs.For(w, cand.Work.Owner);
|
||||
var used = cls == PaxClass.Staff ? usedStaff : usedWorkers;
|
||||
double capacity = double.MaxValue;
|
||||
foreach (var hop in cand.Conn.Hops)
|
||||
{
|
||||
if (!graph.DailyCapacity.TryGetValue(hop.Line.Value, out var cap)) { capacity = 0; break; }
|
||||
double seats = (cls == PaxClass.Staff ? cap.Staff : cap.Workers) * eb.LineCapacityUtilization;
|
||||
capacity = Math.Min(capacity, seats - used.GetValueOrDefault(hop.Line.Value));
|
||||
}
|
||||
int take = Math.Min(limit, Math.Min(free, (int)Math.Floor(Math.Max(0, capacity))));
|
||||
if (take <= 0) return 0;
|
||||
var contract = new CommuteContract
|
||||
{
|
||||
Id = new ContractId(w.NextIds.Contract++),
|
||||
Town = cand.Town.Id,
|
||||
Workplace = WorkplaceRef.Of(ind.Id),
|
||||
Category = cls,
|
||||
Headcount = take,
|
||||
Carrier = cand.Work.Owner,
|
||||
HomeStation = cand.Home.Id,
|
||||
WorkStation = cand.Work.Id,
|
||||
ExpectedMinutes = cand.Minutes,
|
||||
Coverage = eb.RailStartCoverage,
|
||||
};
|
||||
foreach (var hop in cand.Conn.Hops)
|
||||
{
|
||||
if (!contract.Route.Contains(hop.Line)) contract.Route.Add(hop.Line);
|
||||
used[hop.Line.Value] = used.GetValueOrDefault(hop.Line.Value) + take;
|
||||
}
|
||||
w.Commutes.Add(contract);
|
||||
if (cls == PaxClass.Staff)
|
||||
{
|
||||
cand.Town.EmployedStaff += take;
|
||||
ind.ContractedStaff += take;
|
||||
}
|
||||
else
|
||||
{
|
||||
cand.Town.EmployedWorkers += take;
|
||||
ind.ContractedWorkers += take;
|
||||
}
|
||||
return take;
|
||||
}
|
||||
|
||||
/// <summary>Ogni giorno ogni contratto su rotaia manda i suoi pendolari alla stazione di casa.</summary>
|
||||
private static void GeneratePassengers(WorldContext ctx)
|
||||
{
|
||||
var w = ctx.World;
|
||||
var eb = w.Data.Balance.Employment;
|
||||
foreach (var c in w.Commutes)
|
||||
{
|
||||
if (c.Walking || !c.HomeStation.IsValid) continue;
|
||||
var home = w.Network.Stations[c.HomeStation.Value];
|
||||
var p = new Packet
|
||||
{
|
||||
Id = w.NextIds.Packet++,
|
||||
Kind = c.Category == PaxClass.Staff ? PacketKind.Staff : PacketKind.Workers,
|
||||
Good = -1,
|
||||
Units = c.Headcount,
|
||||
Origin = c.HomeStation,
|
||||
Destination = c.WorkStation,
|
||||
CreatedTick = ctx.Tick,
|
||||
ExpiresTick = ctx.Tick + (long)eb.BoardDays * w.Calendar.TicksPerDay,
|
||||
Contract = c.Id.Value,
|
||||
};
|
||||
if (StationWork.Route(w, home, ref p)) home.Waiting.Add(p);
|
||||
}
|
||||
}
|
||||
|
||||
private static void AddWalking(World w, Town town, Industry ind, PaxClass category, int headcount, double km, EmploymentBalance eb)
|
||||
@@ -118,6 +311,10 @@ public sealed class EmploymentSystem : ISimSystem
|
||||
/// <summary>Posti coperti da chi vive in sede (quota fissa dei posti, frazionaria).</summary>
|
||||
public static double OnSite(int jobs, double share) => jobs * share;
|
||||
|
||||
/// <summary>Posti da coprire con i pendolari: la parte frazionaria scoperta conta come un posto intero.</summary>
|
||||
public static int OpenJobs(int jobs, double share, int contracted) =>
|
||||
Math.Max(0, (int)Math.Ceiling(jobs - OnSite(jobs, share) - contracted - 1e-9));
|
||||
|
||||
private static void UpdatePresence(WorldContext ctx)
|
||||
{
|
||||
var w = ctx.World;
|
||||
@@ -130,15 +327,18 @@ public sealed class EmploymentSystem : ISimSystem
|
||||
}
|
||||
foreach (var c in w.Commutes)
|
||||
{
|
||||
// a piedi si arriva sempre; su rotaia contano i passeggeri consegnati (F4)
|
||||
// a piedi si arriva sempre; su rotaia contano i pendolari consegnati, mediati su 30 giorni
|
||||
// (i treni arrivano a ondate: il rapporto giornaliero non si tronca)
|
||||
if (c.Walking) c.ArrivedToday = c.Headcount;
|
||||
double ratio = c.Headcount > 0 ? Math.Min(1.0, (double)c.ArrivedToday / c.Headcount) : 0;
|
||||
double ratio = c.Headcount > 0 ? (double)c.ArrivedToday / c.Headcount : 0;
|
||||
c.Coverage = Ema.Step(c.Coverage, ratio, eb.CoverageEmaDays);
|
||||
if (!c.Walking) c.LowCoverageDays = c.Coverage < eb.DissolveCoverage ? c.LowCoverageDays + 1 : 0;
|
||||
double present = c.Walking ? c.Headcount : c.Headcount * Math.Min(1.0, c.Coverage);
|
||||
if (c.Workplace.Kind == WorkplaceKind.Industry)
|
||||
{
|
||||
var ind = w.Industries[c.Workplace.Index];
|
||||
if (c.Category == PaxClass.Staff) ind.StaffPresent += c.ArrivedToday;
|
||||
else ind.WorkersPresent += c.ArrivedToday;
|
||||
if (c.Category == PaxClass.Staff) ind.StaffPresent += present;
|
||||
else ind.WorkersPresent += present;
|
||||
}
|
||||
if (!c.Walking) c.ArrivedToday = 0;
|
||||
}
|
||||
|
||||
@@ -55,7 +55,7 @@ public sealed class MarketSystem : ISimSystem
|
||||
market.CapacityToday[g] = 0;
|
||||
continue;
|
||||
}
|
||||
double pw = pb * Math.Max(0.05, 1 + Market.WorldFactor(m, volatility, years, market.Shock[g]));
|
||||
double pw = pb * Math.Max(m.World.PriceFloor, 1 + Market.WorldFactor(m, volatility, years, market.Shock[g]));
|
||||
double d = market.Demand[g].Sum;
|
||||
double s = market.Supply[g].Sum;
|
||||
double v = Math.Max(m.World.BaselinePerDay * market.Demand[g].Count, m.World.VolumeShare * (d + s) / 2);
|
||||
|
||||
@@ -25,7 +25,6 @@ public sealed class StationSystem : ISimSystem
|
||||
{
|
||||
foreach (var s in net.Stations) RailCommandHandlers.UpdateCatchment(w, s);
|
||||
}
|
||||
MarkServed(w, ctx.Day);
|
||||
foreach (var s in net.Stations)
|
||||
{
|
||||
if (net.Nodes[s.Node.Value].Station != s.Id) continue;
|
||||
@@ -39,32 +38,6 @@ public sealed class StationSystem : ISimSystem
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>Un'industria è servita se sta nel bacino di una stazione fermata di una linea con treni.</summary>
|
||||
private static void MarkServed(World w, long day)
|
||||
{
|
||||
foreach (var s in w.Network.Stations)
|
||||
{
|
||||
if (!IsServedStation(w, s)) continue;
|
||||
foreach (var id in s.Industries) w.Industries[id.Value].LastServedDay = day;
|
||||
}
|
||||
}
|
||||
|
||||
private static bool IsServedStation(World w, Station s)
|
||||
{
|
||||
foreach (var line in w.Lines)
|
||||
{
|
||||
if (line.Removed || line.Owner != s.Owner) continue;
|
||||
bool stops = false;
|
||||
foreach (var st in line.Stops) if (st.Station == s.Id) { stops = true; break; }
|
||||
if (!stops) continue;
|
||||
foreach (var t in w.Trains)
|
||||
{
|
||||
if (!t.Removed && t.Line == line.Id) return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
private static bool LoadsHere(World w, Station s)
|
||||
{
|
||||
foreach (var line in w.Lines)
|
||||
@@ -116,8 +89,6 @@ public sealed class StationSystem : ISimSystem
|
||||
{
|
||||
var w = ctx.World;
|
||||
var graph = w.LineGraphs.For(w, s.Owner);
|
||||
var reach = graph.From(s.Id);
|
||||
if (reach.Count == 0) return;
|
||||
foreach (var id in s.Industries)
|
||||
{
|
||||
var ind = w.Industries[id.Value];
|
||||
@@ -128,6 +99,8 @@ public sealed class StationSystem : ISimSystem
|
||||
int good = outputs[o].GoodIndex;
|
||||
int units = ind.OutputStock[o];
|
||||
if (units <= 0) continue;
|
||||
var reach = graph.From(s.Id, LineGraph.GoodCargo(good));
|
||||
if (reach.Count == 0) continue;
|
||||
var dest = BestDestination(w, s, reach, good);
|
||||
if (dest is null) continue;
|
||||
var p = new Packet
|
||||
@@ -146,6 +119,7 @@ public sealed class StationSystem : ISimSystem
|
||||
Contract = -1,
|
||||
};
|
||||
ind.OutputStock[o] = 0;
|
||||
ind.LastServedDay = ctx.Day;
|
||||
s.Waiting.Add(p);
|
||||
w.Network.Stations[dest.Destination.Value].Incoming[good] += units;
|
||||
var sale = Money.FromCentsRounded(units * w.Market.GlobalPrice[good]);
|
||||
|
||||
@@ -185,7 +185,7 @@ public static class StationWork
|
||||
public static bool Route(World w, Station from, ref Packet p)
|
||||
{
|
||||
var graph = w.LineGraphs.For(w, from.Owner);
|
||||
if (!graph.From(from.Id).TryGetValue(p.Destination.Value, out var conn)) return false;
|
||||
if (!graph.From(from.Id, LineGraph.CargoOf(p)).TryGetValue(p.Destination.Value, out var conn)) return false;
|
||||
p.HopLine = conn.First.Line;
|
||||
p.HopEnd = conn.First.To;
|
||||
if (p.ExpectedDays <= 0) p.ExpectedDays = w.Calendar.TrainMinutesToDays(conn.Minutes);
|
||||
@@ -210,6 +210,7 @@ public static class StationWork
|
||||
int take = Math.Min(units, Math.Max(0, free));
|
||||
if (take <= 0) continue;
|
||||
ind.InputStock[i] += take;
|
||||
ind.LastServedDay = w.Clock.Day;
|
||||
units -= take;
|
||||
var cost = Money.FromCentsRounded(take * w.Market.GlobalPrice[good]);
|
||||
w.Money.Transfer(Account.Of(ind.Id), Account.External, cost, LedgerEntry.Other);
|
||||
|
||||
@@ -67,7 +67,7 @@ public sealed class TownSystem : ISimSystem
|
||||
double ratio = Math.Min(1.0, _catConsumed[c] / _catDemand[c]);
|
||||
town.Satisfaction[c] = Ema.Step(town.Satisfaction[c], ratio, tb.SatisfactionEmaDays);
|
||||
}
|
||||
town.WorkDissatisfaction *= 1.0 - 1.0 / 90.0;
|
||||
town.WorkDissatisfaction *= 1.0 - 1.0 / tb.WorkDissatisfactionDecayDays;
|
||||
}
|
||||
|
||||
private static void Grow(WorldContext ctx, Town town)
|
||||
@@ -86,8 +86,8 @@ public sealed class TownSystem : ISimSystem
|
||||
town.LastGrowth = g;
|
||||
int before = town.Population;
|
||||
town.Population = Math.Clamp((int)Math.Round(town.Population * (1 + g)), 0, tb.MaxPopulation);
|
||||
if (before < 10_000 && town.Population >= 10_000)
|
||||
ctx.Emit(EventKind.Town, EventSeverity.Info, $"{town.Name} supera i 10.000 abitanti", EntityKind.Town, town.Id.Value);
|
||||
if (before < tb.PopulationMilestone && town.Population >= tb.PopulationMilestone)
|
||||
ctx.Emit(EventKind.Town, EventSeverity.Info, $"{town.Name} supera i {Money.GroupThousands((ulong)tb.PopulationMilestone)} abitanti", EntityKind.Town, town.Id.Value);
|
||||
}
|
||||
|
||||
private static void Migrate(WorldContext ctx)
|
||||
@@ -137,7 +137,7 @@ public sealed class TownSystem : ISimSystem
|
||||
{
|
||||
var tp = w.Data.Balance.Map.Towns;
|
||||
double radius = tp.RadiusBaseCells + tp.RadiusPerSqrtPop * Math.Sqrt(town.Population);
|
||||
if (radius <= town.RadiusCells + 0.25) return;
|
||||
if (radius <= town.RadiusCells + tp.RadiusHysteresisCells) return;
|
||||
town.RadiusCells = radius;
|
||||
int r = (int)Math.Ceiling(radius);
|
||||
bool changed = false;
|
||||
|
||||
@@ -583,7 +583,7 @@ public sealed class TrainSystem : ISimSystem
|
||||
foreach (var id in t.Vehicles)
|
||||
{
|
||||
var v = w.Vehicles[id.Value];
|
||||
m += v.Load + v.Pax * 0.08;
|
||||
m += v.Load + v.Pax * w.Data.Construction.Physics.PassengerMassT;
|
||||
}
|
||||
return m;
|
||||
}
|
||||
|
||||
@@ -0,0 +1,262 @@
|
||||
using System.Diagnostics;
|
||||
using ViaFerrea.Core.Commands;
|
||||
using ViaFerrea.Core.Common;
|
||||
using ViaFerrea.Core.Data;
|
||||
using ViaFerrea.Core.Economy;
|
||||
using ViaFerrea.Core.Rail;
|
||||
using ViaFerrea.Core.Simulation;
|
||||
using ViaFerrea.Core.Simulation.Systems;
|
||||
|
||||
namespace ViaFerrea.Tools.Commands;
|
||||
|
||||
/// <summary>
|
||||
/// bench: costruisce con i comandi del protocollo una rete di linee a doppio binario con segnali,
|
||||
/// stazioni a quattro binari e un deposito per linea, vi mette N treni merci e misura il tempo
|
||||
/// di tick (media, percentili, massimo) e la ripartizione per sistema. Obiettivo della guida
|
||||
/// (sezione 15): tick medio ≤ 10 ms con 2.000 treni.
|
||||
/// </summary>
|
||||
public sealed class BenchCommand : IToolCommand
|
||||
{
|
||||
public string Name => "bench";
|
||||
|
||||
public string Usage => "bench --trains 2000 [--size 256] [--seed 1] [--stations 600] [--days 5] [--warmup 3] [--budget-ms 10]";
|
||||
|
||||
public int Run(CommandLine args)
|
||||
{
|
||||
int trainCount = args.Int("trains", 2000);
|
||||
int size = args.Int("size", 256);
|
||||
ulong seed = args.ULong("seed", 1);
|
||||
int stationCount = args.Int("stations", 600);
|
||||
int days = args.Int("days", 5);
|
||||
int warmupDays = args.Int("warmup", 3);
|
||||
double budgetMs = args.Double("budget-ms", 10);
|
||||
args.EnsureAllUsed();
|
||||
|
||||
var data = GameData.LoadDefault();
|
||||
var total = Stopwatch.StartNew();
|
||||
var w = WorldFactory.Create(data, new NewGameSettings { Seed = seed, SizeKm = size });
|
||||
long createMs = total.ElapsedMilliseconds;
|
||||
Console.WriteLine($"bench: mappa {size} km (seme {seed}) in {createMs} ms; {w.Industries.Count} industrie, {w.Towns.Count} città");
|
||||
|
||||
var me = w.Player.Id;
|
||||
// cassa illimitata per il banco di prova (registrata come movimento esterno: gli invarianti reggono)
|
||||
w.Money.Transfer(Account.External, Account.Of(me), new Money(1_000_000_000_000_00), LedgerEntry.Other);
|
||||
|
||||
var build = Stopwatch.StartNew();
|
||||
var lines = BuildNetwork(w, me, stationCount / 2, seed);
|
||||
ConstructionSystem.CompleteAllNow(w);
|
||||
int signals = PlaceSignals(w, me);
|
||||
int trains = BuyTrains(w, me, lines, trainCount);
|
||||
var net = w.Network;
|
||||
var edges = net.Edges.Where(e => e.State != EdgeState.Demolished).ToList();
|
||||
int stations = net.Stations.Count(s => net.Nodes[s.Node.Value].Station == s.Id);
|
||||
Console.WriteLine($" rete: {lines.Count} linee, {stations} stazioni, {edges.Count} archi ({edges.Sum(e => e.Length) / 1000:F0} km), " +
|
||||
$"{signals} segnali, {trains} treni in {build.ElapsedMilliseconds} ms");
|
||||
|
||||
w.RunDays(warmupDays);
|
||||
int ticks = days * w.Calendar.TicksPerDay;
|
||||
var samples = new double[ticks];
|
||||
w.Pipeline.Profile = true;
|
||||
Array.Clear(w.Pipeline.ElapsedTicks);
|
||||
Array.Clear(w.Pipeline.AllocatedBytes);
|
||||
long gc0 = GC.CollectionCount(0);
|
||||
long allocDay = 0, allocOther = 0;
|
||||
for (int i = 0; i < ticks; i++)
|
||||
{
|
||||
bool dayTick = w.Clock.IsNewDay;
|
||||
long before = GC.GetAllocatedBytesForCurrentThread();
|
||||
long start = Stopwatch.GetTimestamp();
|
||||
w.Tick();
|
||||
samples[i] = Stopwatch.GetElapsedTime(start).TotalMilliseconds;
|
||||
long bytes = GC.GetAllocatedBytesForCurrentThread() - before;
|
||||
if (dayTick) allocDay += bytes;
|
||||
else allocOther += bytes;
|
||||
}
|
||||
w.Pipeline.Profile = false;
|
||||
|
||||
var sorted = (double[])samples.Clone();
|
||||
Array.Sort(sorted);
|
||||
double avg = samples.Average();
|
||||
int moving = w.Trains.Count(t => !t.Removed && t.State == TrainState.Moving);
|
||||
int loading = w.Trains.Count(t => !t.Removed && t.State == TrainState.Loading);
|
||||
int packets = w.Network.Stations.Sum(s => s.Waiting.Count) + w.Trains.Sum(t => t.Cargo.Count);
|
||||
Console.WriteLine($" misura: {ticks} tick ({days} giorni dopo {warmupDays} di avvio); treni in moto {moving}, in stazione {loading}, pacchetti {packets}");
|
||||
Console.WriteLine($" tick: media {avg:F2} ms, mediana {Pct(sorted, 0.5):F2}, p95 {Pct(sorted, 0.95):F2}, p99 {Pct(sorted, 0.99):F2}, max {sorted[^1]:F2} ms");
|
||||
Console.WriteLine($" allocazioni: {allocOther / (double)(ticks - days) / 1024:F2} KB per tick ordinario, {allocDay / (double)days / 1024:F0} KB per cambio di giorno, GC gen0 {GC.CollectionCount(0) - gc0}");
|
||||
for (int i = 0; i < w.Pipeline.Systems.Count; i++)
|
||||
{
|
||||
double ms = w.Pipeline.ElapsedTicks[i] * 1000.0 / Stopwatch.Frequency / ticks;
|
||||
double kb = w.Pipeline.AllocatedBytes[i] / 1024.0 / ticks;
|
||||
if (ms >= 0.005 || kb >= 0.01) Console.WriteLine($" {w.Pipeline.Systems[i].Name,-16} {ms,8:F3} ms/tick {kb,8:F2} KB/tick");
|
||||
}
|
||||
bool stalls = w.Events.Recent.Any(e => e.Text.Contains("possibile stallo", StringComparison.Ordinal));
|
||||
Console.WriteLine($" invarianti: denaro {(w.MoneyBalanceSum() == 0 ? "ok" : "ROTTO")}; avvisi di stallo: {(stalls ? "sì" : "no")}");
|
||||
bool ok = avg <= budgetMs;
|
||||
Console.WriteLine(ok ? $" esito: entro il budget di {budgetMs} ms" : $" esito: OLTRE il budget di {budgetMs} ms");
|
||||
return ok ? 0 : 1;
|
||||
}
|
||||
|
||||
private static double Pct(double[] sorted, double p) => sorted[Math.Min(sorted.Length - 1, (int)(p * sorted.Length))];
|
||||
|
||||
private sealed record BenchLine(int StationA, int StationB, int Depot);
|
||||
|
||||
private static CommandResult Do(World w, GameCommand c, CompanyId me)
|
||||
{
|
||||
w.Enqueue(c with { Issuer = me });
|
||||
w.RunTicks(1);
|
||||
return w.DrainResults().Last();
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Linee rettilinee di 6–10 km ancorate alle industrie, lontane tra loro, con stazioni a quattro
|
||||
/// binari alle estremità e un deposito su una diramazione vicino alla prima stazione.
|
||||
/// </summary>
|
||||
private static List<BenchLine> BuildNetwork(World w, CompanyId me, int count, ulong seed)
|
||||
{
|
||||
var rng = new Rng(seed).Fork("bench");
|
||||
var placed = new List<(Vec2 A, Vec2 B)>();
|
||||
var result = new List<BenchLine>();
|
||||
double margin = 3000, spacing = 1500;
|
||||
double maxX = w.Terrain.WidthM - margin, maxY = w.Terrain.HeightM - margin;
|
||||
for (int attempt = 0; result.Count < count && attempt < count * 30; attempt++)
|
||||
{
|
||||
var anchor = w.Industries[rng.NextInt(w.Industries.Count)].Position;
|
||||
double angle = rng.NextDouble(0, 2 * Math.PI);
|
||||
var dir = new Vec2(Math.Cos(angle), Math.Sin(angle));
|
||||
var a = anchor + dir.Perpendicular * rng.NextDouble(400, 1200);
|
||||
var b = a + dir * rng.NextDouble(6000, 10000);
|
||||
if (!Inside(a, margin, maxX, maxY) || !Inside(b, margin, maxX, maxY)) continue;
|
||||
if (placed.Any(s => SegmentDistance(a, b, s.A, s.B) < spacing)) continue;
|
||||
var junction = a + dir * 800;
|
||||
var depotAt = junction + dir.Perpendicular * 350;
|
||||
if (Water(w, a) || Water(w, b) || Water(w, depotAt)) continue;
|
||||
|
||||
var sa = Do(w, new BuildStationCommand(a, 4), me);
|
||||
if (!sa.Ok) continue;
|
||||
var sb = Do(w, new BuildStationCommand(b, 4), me);
|
||||
if (!sb.Ok) { Do(w, new DemolishCommand(DemolishTarget.Station, sa.Created[0]), me); continue; }
|
||||
var track = Do(w, new BuildTrackCommand([a, b], DoubleTrack: true), me);
|
||||
if (!track.Ok)
|
||||
{
|
||||
Do(w, new DemolishCommand(DemolishTarget.Station, sb.Created[0]), me);
|
||||
Do(w, new DemolishCommand(DemolishTarget.Station, sa.Created[0]), me);
|
||||
continue;
|
||||
}
|
||||
var depot = Do(w, new BuildDepotCommand(depotAt, "small"), me);
|
||||
var spur = depot.Ok ? Do(w, new BuildTrackCommand([depotAt, junction]), me) : depot;
|
||||
if (!spur.Ok)
|
||||
{
|
||||
// linea senza deposito: i suoi treni nasceranno nel deposito di un'altra linea, non serve
|
||||
if (depot.Ok) Do(w, new DemolishCommand(DemolishTarget.Depot, depot.Created[0]), me);
|
||||
foreach (var e in track.Created) Do(w, new DemolishCommand(DemolishTarget.Edge, e), me);
|
||||
Do(w, new DemolishCommand(DemolishTarget.Station, sb.Created[0]), me);
|
||||
Do(w, new DemolishCommand(DemolishTarget.Station, sa.Created[0]), me);
|
||||
continue;
|
||||
}
|
||||
placed.Add((a, b));
|
||||
result.Add(new BenchLine(sa.Created[0], sb.Created[0], depot.Created[0]));
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
/// <summary>Segnali ogni 800 m sugli archi principali (non sulle diramazioni dei depositi).</summary>
|
||||
private static int PlaceSignals(World w, CompanyId me)
|
||||
{
|
||||
const double every = 800;
|
||||
int placed = 0;
|
||||
foreach (var e in w.Network.Edges.ToList())
|
||||
{
|
||||
if (e.State != EdgeState.Active || e.Owner != me) continue;
|
||||
if (w.Network.Nodes[e.A.Value].Depot.IsValid || w.Network.Nodes[e.B.Value].Depot.IsValid) continue;
|
||||
for (double s = every; s < e.Length - every / 2; s += every)
|
||||
{
|
||||
w.Enqueue(new PlaceSignalCommand(e.Id, s) with { Issuer = me });
|
||||
placed++;
|
||||
}
|
||||
}
|
||||
w.RunTicks(1);
|
||||
placed -= w.DrainResults().Count(r => !r.Ok);
|
||||
return placed;
|
||||
}
|
||||
|
||||
/// <summary>Compra locomotive e tramogge, compone i treni, crea una linea per tratta e li assegna.</summary>
|
||||
private static int BuyTrains(World w, CompanyId me, List<BenchLine> lines, int count)
|
||||
{
|
||||
if (lines.Count == 0) return 0;
|
||||
var perLine = new int[lines.Count];
|
||||
for (int i = 0; i < count; i++) perLine[i % lines.Count]++;
|
||||
for (int l = 0; l < lines.Count; l++)
|
||||
{
|
||||
for (int k = 0; k < perLine[l]; k++)
|
||||
{
|
||||
w.Enqueue(new BuyVehicleCommand("loco_steam_1850", new DepotId(lines[l].Depot), 1) with { Issuer = me });
|
||||
w.Enqueue(new BuyVehicleCommand("wagon_hopper", new DepotId(lines[l].Depot), 4) with { Issuer = me });
|
||||
}
|
||||
}
|
||||
w.RunTicks(1);
|
||||
var bought = w.DrainResults();
|
||||
int r = 0;
|
||||
for (int l = 0; l < lines.Count; l++)
|
||||
{
|
||||
for (int k = 0; k < perLine[l]; k++)
|
||||
{
|
||||
var ids = bought[r].Created.Concat(bought[r + 1].Created).Select(i => new VehicleId(i)).ToList();
|
||||
r += 2;
|
||||
w.Enqueue(new ComposeTrainCommand(new DepotId(lines[l].Depot), ids) with { Issuer = me });
|
||||
}
|
||||
w.Enqueue(new CreateLineCommand($"Linea {l + 1}", "#e0a526",
|
||||
[new LineStop(new StationId(lines[l].StationA)), new LineStop(new StationId(lines[l].StationB))]) with { Issuer = me });
|
||||
}
|
||||
w.RunTicks(1);
|
||||
var composed = w.DrainResults();
|
||||
int c = 0, trains = 0;
|
||||
for (int l = 0; l < lines.Count; l++)
|
||||
{
|
||||
var trainIds = new List<int>();
|
||||
for (int k = 0; k < perLine[l]; k++)
|
||||
{
|
||||
if (composed[c].Ok) trainIds.Add(composed[c].Created[0]);
|
||||
c++;
|
||||
}
|
||||
var line = composed[c++];
|
||||
if (!line.Ok) continue;
|
||||
foreach (int t in trainIds)
|
||||
{
|
||||
w.Enqueue(new AssignTrainCommand(new TrainId(t), new LineId(line.Created[0])) with { Issuer = me });
|
||||
trains++;
|
||||
}
|
||||
}
|
||||
w.RunTicks(1);
|
||||
trains -= w.DrainResults().Count(x => !x.Ok);
|
||||
return trains;
|
||||
}
|
||||
|
||||
private static bool Inside(Vec2 p, double margin, double maxX, double maxY) => p.X >= margin && p.Y >= margin && p.X <= maxX && p.Y <= maxY;
|
||||
|
||||
private static bool Water(World w, Vec2 p)
|
||||
{
|
||||
var (x, y) = w.Terrain.CellAt(p);
|
||||
return w.Terrain.IsWater(x, y);
|
||||
}
|
||||
|
||||
private static double SegmentDistance(Vec2 a, Vec2 b, Vec2 c, Vec2 d)
|
||||
{
|
||||
if (Intersects(a, b, c, d)) return 0;
|
||||
return Math.Min(Math.Min(PointSegment(a, c, d), PointSegment(b, c, d)), Math.Min(PointSegment(c, a, b), PointSegment(d, a, b)));
|
||||
}
|
||||
|
||||
private static bool Intersects(Vec2 a, Vec2 b, Vec2 c, Vec2 d)
|
||||
{
|
||||
double d1 = Vec2.Cross(b - a, c - a), d2 = Vec2.Cross(b - a, d - a);
|
||||
double d3 = Vec2.Cross(d - c, a - c), d4 = Vec2.Cross(d - c, b - c);
|
||||
return d1 * d2 < 0 && d3 * d4 < 0;
|
||||
}
|
||||
|
||||
private static double PointSegment(Vec2 p, Vec2 a, Vec2 b)
|
||||
{
|
||||
var ab = b - a;
|
||||
double len2 = Vec2.Dot(ab, ab);
|
||||
double t = len2 <= 0 ? 0 : Math.Clamp(Vec2.Dot(p - a, ab) / len2, 0, 1);
|
||||
return Vec2.Distance(p, a + ab * t);
|
||||
}
|
||||
}
|
||||
@@ -11,6 +11,7 @@ public static class ToolsProgram
|
||||
new GenMapCommand(),
|
||||
new SimulateCommand(),
|
||||
new ProfileCommand(),
|
||||
new BenchCommand(),
|
||||
];
|
||||
|
||||
public static int Main(string[] args)
|
||||
|
||||
@@ -0,0 +1,103 @@
|
||||
using ViaFerrea.Core.Commands;
|
||||
using ViaFerrea.Core.Common;
|
||||
using ViaFerrea.Core.Data;
|
||||
using ViaFerrea.Core.Economy;
|
||||
using ViaFerrea.Core.Rail;
|
||||
using ViaFerrea.Tests.Harness;
|
||||
using static ViaFerrea.Tests.Rail.RailFixture;
|
||||
|
||||
namespace ViaFerrea.Tests.Rail;
|
||||
|
||||
public static class CommutingTests
|
||||
{
|
||||
/// <summary>Linea operai Borgo Ceresio ↔ acciaieria con un deposito sulla diramazione.</summary>
|
||||
private static (RailFixture F, Industry Mill, int Train, int Line) WorkersLine(int coaches, int staffCoaches = 0)
|
||||
{
|
||||
var f = Valdoria();
|
||||
int mill = f.Ok(new BuildStationCommand(K(10.6, 5.4), 2, "Acciaieria"));
|
||||
int borgo = f.Ok(new BuildStationCommand(K(12.4, 8.0), 2, "Borgo Ceresio"));
|
||||
int depot = f.Ok(new BuildDepotCommand(K(11.6, 7.4), "small", "Deposito di Borgo"));
|
||||
f.Ok(new BuildTrackCommand(f.Scenario!.Route("borgo", f.Me).Polyline));
|
||||
f.Ok(new BuildTrackCommand(new[] { K(11.6, 7.4), K(11.7, 6.85) }));
|
||||
Assert.True(f.RunUntil(() => f.W.Network.Edges.All(e => e.State == EdgeState.Active), 400), "cantieri completati");
|
||||
int train = staffCoaches > 0
|
||||
? f.Train(depot, "Operai 1", ("loco_steam_1850", 1), ("coach_worker", coaches), ("coach_staff", staffCoaches))
|
||||
: f.Train(depot, "Operai 1", ("loco_steam_1850", 1), ("coach_worker", coaches));
|
||||
int line = f.Ok(new CreateLineCommand("Operai di Borgo", "#4f7cac",
|
||||
new[] { new LineStop(new StationId(borgo)), new LineStop(new StationId(mill)) }));
|
||||
f.Ok(new AssignTrainCommand(new TrainId(train), new LineId(line)));
|
||||
return (f, f.W.Industries.First(i => i.Def.Id == "steel_mill"), train, line);
|
||||
}
|
||||
|
||||
/// <summary>Avanza fino a dopo il prossimo abbinamento mensile.</summary>
|
||||
private static void RunToNextMonth(RailFixture f)
|
||||
{
|
||||
long month = f.W.Clock.Day / f.W.Calendar.DaysPerMonth;
|
||||
while (f.W.Clock.Day / f.W.Calendar.DaysPerMonth == month) f.W.RunDays(1);
|
||||
f.W.RunDays(1);
|
||||
}
|
||||
|
||||
[Test(Description = "Pendolarismo (14.5): con città raggiungibile e capacità sufficiente la copertura supera 0.9 in 60 giorni")]
|
||||
public static void ReachableTownWithCapacityCoversJobsWithinSixtyDays()
|
||||
{
|
||||
var (f, mill, _, _) = WorkersLine(coaches: 2);
|
||||
RunToNextMonth(f);
|
||||
var contracts = f.W.Commutes.Where(c => !c.Walking && c.Workplace.Index == mill.Id.Value && c.Category == PaxClass.Worker).ToList();
|
||||
Assert.True(contracts.Count > 0, "contratti su rotaia creati all'abbinamento mensile");
|
||||
Assert.Equal(mill.JobsWorkers - (int)Math.Round(mill.JobsWorkers * f.W.Data.Balance.Industry.OnSiteWorkerShare), contracts.Sum(c => c.Headcount));
|
||||
foreach (var c in contracts)
|
||||
{
|
||||
Assert.Equal("Borgo Ceresio", f.W.Towns[c.Town.Value].Name);
|
||||
Assert.True(c.ExpectedMinutes <= f.W.Data.Balance.Employment.WorkerMaxMinutes);
|
||||
}
|
||||
f.W.RunDays(60);
|
||||
foreach (var c in contracts) Assert.True(c.Coverage > 0.9, $"copertura del contratto {c.Coverage:F2}");
|
||||
Assert.True(mill.CovWorkers > 0.9, $"copertura dei lavoratori dell'acciaieria {mill.CovWorkers:F2}");
|
||||
Assert.True(f.W.Player.YearEntries[(int)LedgerEntry.PassengerRevenue] > 0, "tariffe incassate");
|
||||
Assert.Equal(0L, f.W.MoneyBalanceSum());
|
||||
}
|
||||
|
||||
[Test(Description = "L'abbinamento non supera la capacità residua stimata della linea")]
|
||||
public static void MatchingRespectsLineCapacity()
|
||||
{
|
||||
var (f, mill, _, line) = WorkersLine(coaches: 1);
|
||||
// l'acciaieria al livello 3 offre più posti di quanti una carrozza ne porti
|
||||
mill.Level = 3;
|
||||
RunToNextMonth(f);
|
||||
var graph = f.W.LineGraphs.For(f.W, f.Me);
|
||||
double seats = graph.DailyCapacity[line].Workers * f.W.Data.Balance.Employment.LineCapacityUtilization;
|
||||
int contracted = f.W.Commutes.Where(c => !c.Walking).Sum(c => c.Headcount);
|
||||
Assert.True(contracted > 0 && contracted <= seats, $"{contracted} pendolari per {seats:F0} posti al giorno");
|
||||
Assert.True(contracted < EmploymentOpen(f, mill), "restano posti scoperti per mancanza di carrozze");
|
||||
}
|
||||
|
||||
private static int EmploymentOpen(RailFixture f, Industry mill) =>
|
||||
mill.JobsWorkers - (int)Math.Round(mill.JobsWorkers * f.W.Data.Balance.Industry.OnSiteWorkerShare);
|
||||
|
||||
[Test(Description = "Senza più treni sulla linea i contratti si sciolgono e la città se ne lamenta")]
|
||||
public static void ContractsDissolveWhenTheRouteDisappears()
|
||||
{
|
||||
var (f, mill, train, _) = WorkersLine(coaches: 2);
|
||||
RunToNextMonth(f);
|
||||
Assert.True(f.W.Commutes.Any(c => !c.Walking));
|
||||
var borgo = f.W.Towns.First(t => t.Name == "Borgo Ceresio");
|
||||
int employedBefore = borgo.EmployedWorkers;
|
||||
f.Ok(new AssignTrainCommand(new TrainId(train), LineId.None));
|
||||
RunToNextMonth(f);
|
||||
Assert.False(f.W.Commutes.Any(c => !c.Walking), "contratti sciolti");
|
||||
Assert.True(borgo.WorkDissatisfaction > 0, "insoddisfazione «lavoro»");
|
||||
Assert.True(borgo.EmployedWorkers < employedBefore, "i lavoratori tornano liberi");
|
||||
Assert.True(f.W.Events.Recent.Any(e => e.Text.Contains("perdono il posto", StringComparison.Ordinal)));
|
||||
Assert.Equal(0, mill.ContractedWorkers);
|
||||
}
|
||||
|
||||
[Test(Description = "Il personale qualificato viene solo da città con servizi: Borgo Ceresio non ne fornisce")]
|
||||
public static void StaffComesOnlyFromTownsWithServices()
|
||||
{
|
||||
var (f, mill, _, _) = WorkersLine(coaches: 2, staffCoaches: 1);
|
||||
RunToNextMonth(f);
|
||||
Assert.True(f.W.Commutes.Any(c => !c.Walking && c.Category == PaxClass.Worker));
|
||||
Assert.False(f.W.Commutes.Any(c => !c.Walking && c.Category == PaxClass.Staff));
|
||||
Assert.True(mill.StaffPresent < mill.JobsStaff, "il personale resta scoperto");
|
||||
}
|
||||
}
|
||||
@@ -60,6 +60,14 @@ public sealed class RailFixture
|
||||
return Ok(new ComposeTrainCommand(new DepotId(depot), ids, name));
|
||||
}
|
||||
|
||||
/// <summary>Compra veicoli di più tipi e compone un treno nel deposito.</summary>
|
||||
public int Train(int depot, string name, params (string Type, int Count)[] vehicles)
|
||||
{
|
||||
var ids = new List<VehicleId>();
|
||||
foreach (var (type, count) in vehicles) ids.AddRange(W_Buy(type, depot, count));
|
||||
return Ok(new ComposeTrainCommand(new DepotId(depot), ids, name));
|
||||
}
|
||||
|
||||
private IEnumerable<VehicleId> W_Buy(string type, int depot, int count) =>
|
||||
Do(new BuyVehicleCommand(type, new DepotId(depot), count)).Created.Select(i => new VehicleId(i));
|
||||
|
||||
|
||||
@@ -31,7 +31,7 @@ public static class TrainTests
|
||||
Assert.True(t.Odometer > 50_000, $"il treno ha viaggiato ({t.Odometer / 1000:F1} km)");
|
||||
Assert.True(steel.InputStock.All(s => s > 0), "l'acciaieria riceve minerale e carbone");
|
||||
Assert.True(f.W.Player.YearEntries[(int)LedgerEntry.FreightRevenue] > revenueBefore, "tariffe incassate");
|
||||
Assert.True(steel.ServedWithin(f.W.Clock.Day, 1), "industria servita");
|
||||
Assert.True(steel.ServedWithin(f.W.Clock.Day, 10), "industria servita dal vettore");
|
||||
Assert.Equal(0L, f.W.MoneyBalanceSum());
|
||||
for (int g = 0; g < f.W.Data.GoodCount; g++)
|
||||
Assert.Equal(f.W.Goods.ExpectedStock(g), f.W.TotalStock(g), $"merce {f.W.Data.Goods[g].Id}");
|
||||
|
||||
@@ -0,0 +1,74 @@
|
||||
using ViaFerrea.Core.Commands;
|
||||
using ViaFerrea.Core.Common;
|
||||
using ViaFerrea.Core.Data;
|
||||
using ViaFerrea.Core.Rail;
|
||||
using ViaFerrea.Tests.Harness;
|
||||
using ViaFerrea.Tests.Rail;
|
||||
using static ViaFerrea.Tests.Rail.RailFixture;
|
||||
|
||||
namespace ViaFerrea.Tests.Scenarios;
|
||||
|
||||
public static class CommutingAcceptanceTests
|
||||
{
|
||||
/// <summary>
|
||||
/// Rete di Valdoria con tre linee: merci (miniere → acciaieria → Valdoria, con minerale, carbone
|
||||
/// e acciaio), lavoratori (Borgo Ceresio → acciaieria) e personale (Valdoria → acciaieria).
|
||||
/// </summary>
|
||||
private static (RailFixture F, Core.Economy.Industry Mill) ThreeLines()
|
||||
{
|
||||
var f = Valdoria();
|
||||
var (mine, mill, depot) = f.BuildFreightNetwork(waitForConstruction: false);
|
||||
int borgo = f.Ok(new BuildStationCommand(K(12.4, 8.0), 2, "Borgo Ceresio"));
|
||||
int valdoria = f.Ok(new BuildStationCommand(K(12.8, 4.9), 2, "Valdoria"));
|
||||
f.Ok(new BuildTrackCommand(f.Scenario!.Route("borgo", f.Me).Polyline));
|
||||
f.Ok(new BuildTrackCommand(f.Scenario!.Route("valdoria", f.Me).Polyline));
|
||||
Assert.True(f.RunUntil(() => f.W.Network.Edges.All(e => e.State == EdgeState.Active), 500), "cantieri completati");
|
||||
|
||||
var steel = f.W.Industries.First(i => i.Def.Id == "steel_mill");
|
||||
Assert.True(steel.Efficiency < 0.4, $"efficienza iniziale {steel.Efficiency:P0}");
|
||||
|
||||
int freight = f.Train(depot, "Merci 1", ("loco_steam_1850", 1), ("wagon_hopper", 6), ("wagon_flat", 2));
|
||||
int workers = f.Train(depot, "Operai 1", ("loco_steam_1850", 1), ("coach_worker", 2));
|
||||
int staff = f.Train(depot, "Tecnici 1", ("loco_steam_1850", 1), ("coach_staff", 1));
|
||||
int lineFreight = f.Ok(new CreateLineCommand("Linea 1, minerale, carbone e acciaio", "#e0a526",
|
||||
new[] { new LineStop(new StationId(mine)), new LineStop(new StationId(mill)), new LineStop(new StationId(valdoria)) }));
|
||||
int lineWorkers = f.Ok(new CreateLineCommand("Linea 2, operai di Borgo", "#4f7cac",
|
||||
new[] { new LineStop(new StationId(borgo)), new LineStop(new StationId(mill)) }));
|
||||
int lineStaff = f.Ok(new CreateLineCommand("Linea 3, tecnici di Valdoria", "#b3573e",
|
||||
new[] { new LineStop(new StationId(valdoria)), new LineStop(new StationId(mill)) }));
|
||||
f.Ok(new AssignTrainCommand(new TrainId(freight), new LineId(lineFreight)));
|
||||
f.Ok(new AssignTrainCommand(new TrainId(workers), new LineId(lineWorkers)));
|
||||
f.Ok(new AssignTrainCommand(new TrainId(staff), new LineId(lineStaff)));
|
||||
return (f, steel);
|
||||
}
|
||||
|
||||
[Test(Description = "Accettazione F2: con tre linee (merci, lavoratori, personale) l'acciaieria passa da < 40 % a > 80 % in 2 anni senza stalli")]
|
||||
public static void ThreeLinesBringTheSteelMillAboveEightyPercent()
|
||||
{
|
||||
var (f, steel) = ThreeLines();
|
||||
int startLevel = steel.Level;
|
||||
double bestMonth = 0;
|
||||
int dpm = f.W.Calendar.DaysPerMonth;
|
||||
for (int month = 0; month < 24; month++)
|
||||
{
|
||||
// media mensile dell'efficienza giornaliera: un picco di un giorno non basta
|
||||
double sum = 0;
|
||||
for (int d = 0; d < dpm; d++)
|
||||
{
|
||||
f.W.RunDays(1);
|
||||
sum += steel.Efficiency;
|
||||
}
|
||||
bestMonth = Math.Max(bestMonth, sum / dpm);
|
||||
}
|
||||
Assert.True(bestMonth > 0.8, $"efficienza media mensile massima {bestMonth:P0}");
|
||||
Assert.False(steel.Closed);
|
||||
Assert.True(steel.Level >= startLevel, $"livello {steel.Level}");
|
||||
Assert.False(f.W.Events.Recent.Any(e => e.Text.Contains("possibile stallo", StringComparison.Ordinal)), "nessuno stallo");
|
||||
Assert.True(f.W.Commutes.Any(c => !c.Walking && c.Category == PaxClass.Worker), "contratti di lavoratori su rotaia");
|
||||
Assert.True(f.W.Commutes.Any(c => !c.Walking && c.Category == PaxClass.Staff), "contratti di personale su rotaia");
|
||||
Assert.True(f.W.Player.YearEntries[(int)Core.Economy.LedgerEntry.PassengerRevenue] > 0, "tariffe dei pendolari incassate");
|
||||
Assert.Equal(0L, f.W.MoneyBalanceSum());
|
||||
for (int g = 0; g < f.W.Data.GoodCount; g++)
|
||||
Assert.Equal(f.W.Goods.ExpectedStock(g), f.W.TotalStock(g), $"merce {f.W.Data.Goods[g].Id}");
|
||||
}
|
||||
}
|
||||
@@ -28,8 +28,8 @@
|
||||
{ "name": "Sant'Elia", "x": 10.2, "y": 1.2, "population": 2200 }
|
||||
],
|
||||
"industries": [
|
||||
{ "type": "iron_mine", "name": "Miniera di ferro Rocca Bruna", "x": 1.2, "y": 3.0, "level": 2, "reserveTonnes": 600000 },
|
||||
{ "type": "coal_mine", "name": "Miniera di carbone Monteferro", "x": 1.8, "y": 1.4, "level": 2, "reserveTonnes": 600000 },
|
||||
{ "type": "iron_mine", "name": "Miniera di ferro Rocca Bruna", "x": 1.2, "y": 3.0, "level": 4, "reserveTonnes": 600000 },
|
||||
{ "type": "coal_mine", "name": "Miniera di carbone Monteferro", "x": 1.8, "y": 1.4, "level": 3, "reserveTonnes": 600000 },
|
||||
{ "type": "steel_mill", "name": "Acciaieria di Valdoria", "x": 10.8, "y": 4.4, "level": 1 },
|
||||
{ "type": "tool_factory", "name": "Fabbrica di attrezzi", "x": 12.6, "y": 3.0, "level": 1 },
|
||||
{ "type": "farm", "name": "Fattoria Piana Verde", "x": 12.0, "y": 6.6, "level": 1 }
|
||||
|
||||
Reference in new issue
Block a user