F6: ere e obsolescenza, correzioni della revisione
Due revisori hanno trovato 12 rilievi. I principali: - Il rinnovo si ricontrolla all'avvio dei lavori: piano, spesa e cassa possono cambiare tra prenotazione e avvio. Se la cassa non basta il rinnovo si annulla senza pagare e con un avviso, così non va mai in scoperto. - La cassa impegnata dai rinnovi prenotati e non ancora avviati (Obsolescence.Committed) conta per il giocatore e per le IA, così la stessa cassa non si spende due volte nello stesso mese. - Le IA comprano il successore solo se non peggiora il treno, e rinnovano solo se le prestazioni restano almeno quelle di oggi. - Dopo un deragliamento la ricostruzione non ringiovanisce nel patrimonio un modello fuori produzione. - Quadro della flotta e pannelli mostrano un rinnovo già prenotato e la spesa netta al netto degli altri rinnovi. Suite completa 210 su 210, client senza avvisi. Refs #41. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
1 parent
f7c286bf1d
commit
b7737455c6
18 files changed
+447
-96
No files matched your search
@@ -701,3 +701,5 @@ superato,,superseded
|
||||
superato dal {0},,superseded since {0}
|
||||
valore {0},,value {0}
|
||||
"{0}: {1} veicoli da rinnovare, spesa netta {2}",,"{0}: {1} vehicles to renew, net cost {2}"
|
||||
rinnovo prenotato,,renewal booked
|
||||
Rinnovo già prenotato.,,Renewal already booked.
|
||||
|
@@ -40,6 +40,10 @@ public partial class MaintenancePanel : VBoxContainer
|
||||
private double _request;
|
||||
private long _fleetDay = long.MinValue;
|
||||
private double _sinceFleet = double.MaxValue;
|
||||
// quadro della flotta mostrato: la sezione si ricostruisce solo quando ne arriva uno nuovo, così i
|
||||
// pulsanti «Rinnova» non si ricreano sotto il cursore a ogni aggiornamento della cartella
|
||||
private FleetReport? _fleetShown;
|
||||
private bool _fleetBuilt;
|
||||
private bool _updating;
|
||||
|
||||
public event Action<bool>? HeatMapToggled;
|
||||
@@ -184,7 +188,7 @@ public partial class MaintenancePanel : VBoxContainer
|
||||
|
||||
BuildCard();
|
||||
BuildWorkshop();
|
||||
BuildFleet();
|
||||
if (!_fleetBuilt || !ReferenceEquals(w.Fleet, _fleetShown)) BuildFleet();
|
||||
}
|
||||
|
||||
private string DueText(TrainInfo t)
|
||||
@@ -326,14 +330,16 @@ public partial class MaintenancePanel : VBoxContainer
|
||||
foreach (var c in _fleet.GetChildren()) c.QueueFree();
|
||||
var w = _session.World;
|
||||
var report = w.Fleet;
|
||||
_fleetShown = report;
|
||||
_fleetBuilt = true;
|
||||
if (report is null)
|
||||
{
|
||||
_fleet.AddChild(UiTheme.Text(T("Quadro della flotta in arrivo dal server…"), 13, Palette.TextSecondary));
|
||||
return;
|
||||
}
|
||||
_fleet.AddChild(PanelKit.Pair(T("Era"), PanelKit.Value(report.Era)));
|
||||
_fleet.AddChild(PanelKit.Pair(T("Era"), PanelKit.Value(EraName(report.Era))));
|
||||
if (report.NextEra.Length > 0)
|
||||
_fleet.AddChild(PanelKit.Pair(T("Prossima era"), PanelKit.Value($"{report.NextEra} · {report.NextEraYear}")));
|
||||
_fleet.AddChild(PanelKit.Pair(T("Prossima era"), PanelKit.Value($"{EraName(report.NextEra)} · {report.NextEraYear}")));
|
||||
_fleet.AddChild(PanelKit.Pair(T("Valore della flotta"), PanelKit.Value(report.BookValueTotal.ToString())));
|
||||
var superseded = report.Vehicles.Where(v => v.Superseded).ToList();
|
||||
if (superseded.Count == 0)
|
||||
@@ -362,14 +368,26 @@ public partial class MaintenancePanel : VBoxContainer
|
||||
text.SizeFlagsHorizontal = SizeFlags.ExpandFill;
|
||||
text.AutowrapMode = TextServer.AutowrapMode.WordSmart;
|
||||
row.AddChild(text);
|
||||
int train = r.Train;
|
||||
var button = new Button { Text = T("Rinnova") };
|
||||
button.Pressed += () => _session.Command(new ScheduleServiceCommand(new TrainId(train), report.RenewalIntervention), Result);
|
||||
row.AddChild(button);
|
||||
if (r.Booked)
|
||||
{
|
||||
// rinnovo già prenotato: niente pulsante, ripremerlo rifarebbe la prenotazione
|
||||
row.AddChild(UiTheme.Text(T("rinnovo prenotato"), 13, Palette.TextSecondary));
|
||||
}
|
||||
else
|
||||
{
|
||||
int train = r.Train;
|
||||
string intervention = report.RenewalIntervention;
|
||||
var button = new Button { Text = T("Rinnova") };
|
||||
button.Pressed += () => _session.Command(new ScheduleServiceCommand(new TrainId(train), intervention), Result);
|
||||
row.AddChild(button);
|
||||
}
|
||||
_fleet.AddChild(row);
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>Nome italiano dell'era dal suo id in eras.json (il quadro della flotta manda l'id).</summary>
|
||||
private string EraName(string id) => _session.World.Data.Eras.Eras.FirstOrDefault(e => e.Id == id)?.NameIt ?? id;
|
||||
|
||||
// ------------------------------------------------------------------ registro officina
|
||||
|
||||
private void BuildWorkshop()
|
||||
|
||||
@@ -188,9 +188,10 @@ public partial class TrainsPanel : VBoxContainer
|
||||
{
|
||||
_trainIds.Add(t.Id);
|
||||
string line = t.Line >= 0 && w.Lines.TryGetValue(t.Line, out var l) ? l.Name : T("senza linea");
|
||||
bool renew = fleet?.Trains.Any(r => r.Train == t.Id) == true;
|
||||
_trains.AddItem($"{t.Name} · {StateName((TrainState)t.State)} · {line}{(renew ? " · " + T("da rinnovare") : "")}");
|
||||
if (renew) _trains.SetItemCustomFgColor(_trains.ItemCount - 1, Palette.Amber);
|
||||
var renewal = fleet?.Trains.FirstOrDefault(r => r.Train == t.Id);
|
||||
string mark = renewal is null ? "" : " · " + (renewal.Booked ? T("rinnovo prenotato") : T("da rinnovare"));
|
||||
_trains.AddItem($"{t.Name} · {StateName((TrainState)t.State)} · {line}{mark}");
|
||||
if (renewal is { Booked: false }) _trains.SetItemCustomFgColor(_trains.ItemCount - 1, Palette.Amber);
|
||||
}
|
||||
int ti = _trainIds.IndexOf(selectedTrain);
|
||||
if (ti >= 0) _trains.Select(ti);
|
||||
@@ -240,7 +241,7 @@ public partial class TrainsPanel : VBoxContainer
|
||||
_renewInfo.Text = renewal is null
|
||||
? ""
|
||||
: string.Format(T("Rinnovo: {0} veicoli superati, spesa netta {1} dopo le rivendite."), renewal.Vehicles, renewal.NetCost)
|
||||
+ (renewal.Affordable ? "" : " " + T("Cassa insufficiente."));
|
||||
+ (renewal.Booked ? " " + T("Rinnovo già prenotato.") : renewal.Affordable ? "" : " " + T("Cassa insufficiente."));
|
||||
}
|
||||
|
||||
public static string StateName(TrainState s) => s switch
|
||||
|
||||
+2
-2
@@ -162,7 +162,7 @@ loro fase i comandi 35–38 rispondono `NotImplemented`. Il server imposta l'emi
|
||||
| 133 | SaveList | `saves: [SaveInfo]` |
|
||||
| 134 | ClimbReport | `day: i64, company: i32, foundedDay: i64, initialCapital: Money, tier: u8, nextTier: u8 (0 all'ultimo livello), tiers: [TierInfo]`; requisiti del prossimo livello: `netWorth, netWorthRequired: Money, netWorthFraction: f32, netWorthMet: bool, towns, townsRequired, townPopulation: i32, townsFraction: f32, townsMet: bool, rating, ratingRequired: string, ratingFraction: f32, ratingMet: bool, progress: f32` (media delle tre frazioni); stato patrimoniale: `assets: [AmountInfo]` (kind 0 binari e opere, 1 stazioni e depositi, 2 veicoli, 3 industrie possedute, 4 merce propria), `portfolio, cash (positiva), totalAssets, loans: Money, loansRate: f32 (medio), overdraft (scoperto), totalLiabilities, balanceNetWorth: Money` (= totalAssets − totalLiabilities = patrimonio netto del motore); conto economico: `incomeYear: i32, incomePartial: bool, income: [AmountInfo]` (kind 0 tariffe e noli, 1 altri ricavi, 2 costi operativi, 3 manutenzione, 4 interessi; con segno), `profit: Money`; prestiti: `loanList: [LoanInfo], maxLoan, loanAvailable: Money, newLoanRate: f32, loansAllowed: bool`; `history: [NetWorthPointInfo]` (fondazione, fine di ogni anno, oggi) (su richiesta, F6; ADR 0018) |
|
||||
| 135 | FinanceReport | `day: i64, company: i32, cash, netWorth, loans, overdraft: Money`; conto economico: `lines: [FinanceLineInfo]` (voci in ordine di presentazione), `columns: [IncomeColumnInfo]` (mese in corso, mesi chiusi dal più recente, anno in corso, anni chiusi dal più recente); rating: `rating: string, ratingInitial: bool, ratingMonths, revenueMonths: u8, marginNeutral: bool (margine 0 finché la finestra non è piena e ha meno di minRevenueMonths mesi con ricavi), minRevenueMonths: u8, margin, leverage: f32, leverageUnbounded: bool, marginWeight, leverageWeight, marginComponent, leverageComponent, score: f32, thresholds: [RatingThresholdInfo], nextRating: string ("" ad AAA), nextThreshold: f32, nextAlreadyMet: bool (il punteggio basta già: rating scoreRating al prossimo calcolo mensile, obiettivi a zero), scoreRating: string, marginNeeded: f32, marginReachable: bool, leverageMax: f32 (sempre finita), leverageReachable: bool, debtToRepay: Money, repayAffordable: bool (il rimborso non supera la cassa né il residuo dei prestiti; lo scoperto non si rimborsa)`; prestiti: `loanList: [FinanceLoanInfo], maxLoan, loanAvailable: Money, newLoanRate, baseRate, spread: f32, loanTermMonths: i32, loanStep: Money, loansAllowed: bool`; bancarotta: `negativeCashDays, bankruptcyDays: i32, bankrupt, receivership: bool` (su richiesta, F6; ADR 0019) |
|
||||
| 136 | FleetReport | `day: i64, company, year: i32, era, nextEra: string ("" all'ultima), nextEraYear: i32 (0 all'ultima), renewalIntervention: string (id per `ScheduleService`), bookValueTotal: Money (coincide con la voce «veicoli» dello stato patrimoniale), vehicles: [FleetVehicleInfo] (veicoli non venduti della compagnia, per id), models: [VehicleModelInfo] (solo i modelli in produzione nell'anno, nell'ordine di vehicles.json), trains: [RenewalTrainInfo] (treni con veicoli da rinnovare)` (su richiesta, F6; ADR 0020) |
|
||||
| 136 | FleetReport | `day: i64, company, year: i32, era, nextEra: string (id di eras.json; nextEra "" all'ultima), nextEraYear: i32 (0 all'ultima), renewalIntervention: string (id per `ScheduleService`), bookValueTotal: Money (coincide con la voce «veicoli» dello stato patrimoniale), vehicles: [FleetVehicleInfo] (veicoli non venduti della compagnia, per id), models: [VehicleModelInfo] (solo i modelli in produzione nell'anno, nell'ordine di vehicles.json), trains: [RenewalTrainInfo] (treni con veicoli da rinnovare)` (su richiesta, F6; ADR 0020) |
|
||||
|
||||
Record (ognuno chiude con `flags`):
|
||||
|
||||
@@ -204,7 +204,7 @@ Record (ognuno chiude con `flags`):
|
||||
- `LedgerEntry` (voce del registro, u8): 0 FreightRevenue (noli merci), 1 PassengerRevenue (biglietti), 2 Construction (costruzioni), 3 VehiclePurchase (acquisto di treni), 4 VehicleSale (vendita di treni), 5 RunningCosts (esercizio dei treni), 6 TrackMaintenance (manutenzione dei binari), 7 FleetMaintenance (manutenzione dei treni), 8 Wages (stipendi), 9 Interest (interessi), 10 LoanTaken (prestiti ricevuti), 11 LoanRepaid (prestiti rimborsati), 12 Trading (commercio in proprio), 13 IndustryPurchase (acquisto di industrie), 14 Dividends (dividendi pagati), 15 Shares (azioni), 16 Contracts (contratti), 17 Penalties (penali), 18 Other (altro), 19 Industries (industrie possedute), 20 Subsidiaries (controllate), 21 StationUpkeep (stazioni e depositi), 22 Storage (magazzini), 23 Duties (dazi), 24 DividendsReceived (dividendi incassati). Sezione: ricavi 0, 1, 12, 16, 19, 20, 24; costi 5–9, 17, 21–23; investimenti e finanziamenti gli altri (ADR 0019)
|
||||
- `FinanceLineInfo { kind: u8 (LedgerEntry), section: u8 (0 ricavi, 1 costi, 2 investimenti e finanziamenti) }`, `IncomeColumnInfo { kind: u8 (0 mese in corso, 1 mese chiuso, 2 anno in corso, 3 anno chiuso), year: i32, month: u8 (1–12, 0 per gli anni), values: [AmountInfo] (solo le voci diverse da zero, kind = LedgerEntry, con segno), profit: Money (utile operativo del motore), cashFlow: Money }`, `RatingThresholdInfo { rating: string, minScore, loanRate: f32 }`, `FinanceLoanInfo { loan: i32, principal, remaining: Money, annualRate: f32 (fisso), monthsLeft: i32, payment, nextInterest: Money, maturityDay: i64 }`
|
||||
- `HubMarketInfo { hub, kind: u8 (0 porto, 1 valico), monthlyCapacity, duty: f32, usedThisMonth, line: i32 (−1 non collegato) }`
|
||||
- `FleetVehicleInfo { vehicle: i32, type: string, train, depot: i32 (−1 se nessuno), ageYears: f32, lifeYears: i32, condition: f32 (media dei componenti, 0–1), inProduction, superseded: bool, supersededYear: i32 (0 senza successore), successor: string (consigliato, "" se non superato o senza successore in produzione), bookValue, resale: Money, maintenanceFactor: f32 }`, `VehicleModelInfo { type: string, superseded: bool, supersededYear: i32, successor: string, lastYear: i32 (ultimo anno di produzione, 0 se non previsto) }`, `RenewalTrainInfo { train, vehicles: i32, netCost: Money (successori − rivendite + lavoro, può essere negativa), affordable: bool }`
|
||||
- `FleetVehicleInfo { vehicle: i32, type: string, train, depot: i32 (−1 se nessuno), ageYears: f32, lifeYears: i32, condition: f32 (media dei componenti, 0–1), inProduction, superseded: bool, supersededYear: i32 (0 senza successore), successor: string (consigliato, "" se non superato o senza successore in produzione), bookValue, resale: Money, maintenanceFactor: f32 }`, `VehicleModelInfo { type: string, superseded: bool, supersededYear: i32, successor: string, lastYear: i32 (ultimo anno di produzione, 0 se non previsto) }`, `RenewalTrainInfo { train, vehicles: i32, netCost: Money (successori − rivendite + lavoro, può essere negativa), affordable: bool (la cassa basta al netto degli altri rinnovi prenotati), booked: bool (rinnovo già prenotato, non ancora avviato) }`
|
||||
- `WarehouseInfo { station, capacity, incoming: i32 (merce propria in viaggio verso la stazione), goods: [WarehouseGoodInfo] }` (stazioni vive della compagnia)
|
||||
- `WarehouseGoodInfo { good, units: i32 (in magazzino), buyPrice: f64 (centesimi, prossima unità; −1 nessun venditore), buyUnits: i32, sellPrice: f64 (−1 nessun compratore), sellUnits: i32 }` (beni in magazzino o scambiabili nel bacino)
|
||||
|
||||
|
||||
+4
-4
@@ -145,14 +145,14 @@ Aggiornato alla fine di ogni fase (guida, sezione 18).
|
||||
- analisi delle lacune nell'ADR: ere, sblocchi per anno, rifiuto d'acquisto fuori produzione, valore di libro per età e `SellVehicle` c'erano già; mancavano notizie d'era e Cronaca, successori e modelli superati, una sola fonte del valore, costi di manutenzione dei superati, un modo di sostituire i veicoli di un treno, il quadro della flotta, la vendita nel client e l'aggiornamento dei modelli dei progetti delle IA;
|
||||
- `vehicles.json`: campo `successor` (stessa categoria, introdotto dopo, validato) e blocco `obsolescence` (perdita immediata 15 %, ammortamento 2 volte più rapido, manutenzione × 1,5 per i superati); catena vapore 1850 → 1878 → 1902 → diesel 1925, elettrica 1950 → alta velocità 1990, carrozza operai → moderna;
|
||||
- `Obsolescence` (senza stato): in produzione, superato dal 1° gennaio dell'anno del successore, successore consigliato, curva del valore, valore di libro (patrimonio) e rivendita (× condizione) da una sola fonte, fattore della manutenzione in `Fleet.CostOf`;
|
||||
- rinnovo con l'intervento «renewal» di `maintenance.json` (effetto `renew`) prenotato con `ScheduleService`: in officina i veicoli superati si vendono e il successore entra nella stessa posizione; nessun comando nuovo; rifiuto senza veicoli superati o con la spesa netta oltre la cassa;
|
||||
- rinnovo con l'intervento «renewal» di `maintenance.json` (effetto `renew`) prenotato con `ScheduleService`: in officina, all'avvio dei lavori, i veicoli superati si vendono e il successore entra nella stessa posizione; nessun comando nuovo; rifiuto senza veicoli superati o con la spesa netta oltre la cassa meno i rinnovi già prenotati; all'avvio piano e cassa si ricontrollano e, se non bastano, il rinnovo si annulla con un avviso senza scoperto; la ricostruzione dopo un deragliamento non rende nuovo nel patrimonio un modello fuori produzione;
|
||||
- `EraSystem`: il 1° gennaio la notizia (`EventKind.Technology` = 11) dell'era che inizia e delle novità dell'anno lette dai dati (trazioni, veicoli, ponti, gallerie, binari, segnali, elettrificazione, merci, industrie, superati, fuori produzione), annotata nella Cronaca; una volta sola anche attraverso un salvataggio;
|
||||
- salvataggio invariato (corpo versione 7): nessuno stato nuovo, «renewal» in coda agli interventi;
|
||||
- IA: i modelli dei progetti fuori produzione passano al successore o al migliore dell'anno; ogni mese al massimo un treno in linea con veicoli superati da 3 anni o a metà vita va al rinnovo se resta in cassa il doppio della riserva (`ai.json`, `renewal`);
|
||||
- IA: i modelli dei progetti superati passano al successore se non peggiora trazione, potenza e velocità, quelli fuori produzione al migliore dell'anno (che scarta i superati); ogni mese al massimo un treno in linea con veicoli superati da 3 anni o a metà vita va al rinnovo se il treno non peggiora e se resta in cassa libera il doppio della riserva (`ai.json`, `renewal`); la spesa dei rinnovi prenotati resta impegnata per borsa, industrie, progetti e treni;
|
||||
- protocollo: `DetailKind.Fleet` (10) e `FleetReport` (136); server: quadro su richiesta; `ClientWorld.Fleet`;
|
||||
- client: Treni con il catalogo dal server (fuori produzione nascosti, superati segnati con il successore, prestazioni e prezzo del successore), rivendita e «superato» sui veicoli liberi, «Vendi», treni «da rinnovare» e «Rinnova i veicoli superati» con la spesa netta; Officine con la riga di obsolescenza nella cartella, il pulsante del rinnovo e la sezione «Rinnovo della flotta»; testi in `strings.csv` (non provato in Godot: manca l'editor);
|
||||
- client: Treni con il catalogo dal server (fuori produzione nascosti, superati segnati con il successore, prestazioni e prezzo del successore), rivendita e «superato» sui veicoli liberi, «Vendi», treni «da rinnovare» e «Rinnova i veicoli superati» con la spesa netta; Officine con la riga di obsolescenza nella cartella, il pulsante del rinnovo e la sezione «Rinnovo della flotta» (nome dell'era, «rinnovo prenotato» al posto di «Rinnova», righe ricostruite solo all'arrivo di un nuovo quadro); testi in `strings.csv` (non provato in Godot: manca l'editor);
|
||||
- accettazione F4 (35 / 20 guasti senza la linea, 75 / 2 con la linea) e F5 invariate;
|
||||
- test (`Economy/ErasTests.cs`, 11, più il round-trip di `FleetReport`): sblocchi per anno, validazione dei successori, notizia d'era una volta anche attraverso un salvataggio, fuori produzione non acquistabile, curva del valore e rivendita, manutenzione dei superati, valore di libro uguale al patrimonio, rinnovo in officina con gli invarianti, determinismo e salvataggio con un rinnovo in corso, quadro e round-trip, un'IA che rinnova (lento). 205 test (185 senza i lenti).
|
||||
- test (`Economy/ErasTests.cs`, 16, più il round-trip di `FleetReport`): sblocchi per anno, validazione dei successori, notizia d'era una volta anche attraverso un salvataggio, fuori produzione non acquistabile, curva del valore e rivendita, manutenzione dei superati, valore di libro uguale al patrimonio, rinnovo in officina con gli invarianti, determinismo e salvataggio con un rinnovo in corso, quadro e round-trip, cassa ricontrollata all'avvio e impegnata tra prenotazioni, rinnovo annullato con il piano vuoto, ricostruzione di un modello fuori produzione, Cronaca di un anno con soli fuori produzione, scelte delle IA, un'IA che rinnova (lento).
|
||||
- Restano della F6: pannello 07, tooltip «perché», tutorial, audio, bilanciamento con i bot.
|
||||
|
||||
## Prossimo passo
|
||||
|
||||
@@ -72,12 +72,21 @@ Mancava:
|
||||
5. **Rinnovo con un intervento dei dati, non con un comando nuovo.** In `maintenance.json` l'intervento
|
||||
«renewal» (effetto nuovo `renew`, 4 giorni, lavoro pari allo 0,5 % dei prezzi di listino pesati dei veicoli del
|
||||
treno per il fattore della politica, nessun ricambio) si prenota con
|
||||
il comando esistente `ScheduleService` (17). In officina, al completamento, ogni veicolo superato del
|
||||
treno con un successore in produzione si vende al valore di rivendita (voce «vendita di treni») e nella
|
||||
stessa posizione della composizione entra un veicolo nuovo del successore consigliato (voce «acquisto
|
||||
di treni», componenti nuovi); il treno ricalcola prestazioni e grafo della linea e torna in servizio.
|
||||
Il comando si rifiuta senza veicoli da rinnovare («nessun veicolo superato da rinnovare») e con una
|
||||
spesa netta (successori − rivendite + lavoro) maggiore della cassa. I veicoli liberi si vendono con
|
||||
il comando esistente `ScheduleService` (17). In officina, **all'avvio dei lavori** (quando il treno
|
||||
prende uno stallo e si paga il lavoro), ogni veicolo superato del treno con un successore in produzione
|
||||
si vende al valore di rivendita (voce «vendita di treni») e nella stessa posizione della composizione
|
||||
entra un veicolo nuovo del successore consigliato (voce «acquisto di treni», componenti nuovi); il treno
|
||||
ricalcola prestazioni e grafo della linea e i giorni d'officina sono la messa in servizio; al
|
||||
completamento torna in linea. Il comando si rifiuta senza veicoli da rinnovare («nessun veicolo
|
||||
superato da rinnovare») e con una spesa netta (successori − rivendite + lavoro) maggiore della cassa
|
||||
meno la spesa già impegnata dagli altri rinnovi prenotati e non ancora avviati
|
||||
(`Obsolescence.Committed`). All'avvio piano, spesa e cassa si ricontrollano: tra prenotazione e avvio
|
||||
l'anno può cambiare il piano (un successore esce di produzione, altri veicoli diventano superati) e la
|
||||
cassa può essersi spesa altrove. Se il piano è vuoto o la cassa non basta, il rinnovo si annulla senza
|
||||
pagare nulla, il treno esce dall'officina e una notizia di avviso lo dice; così la cassa non va mai in
|
||||
scoperto per un rinnovo. Il piano pagato è quello del giorno dell'avvio, che può includere veicoli
|
||||
diventati superati dopo la prenotazione: salvare il piano prenotato vorrebbe dire stato nuovo nel
|
||||
salvataggio, e il controllo della cassa all'avvio basta a evitare spese non coperte. I veicoli liberi si vendono con
|
||||
`SellVehicle`, com'era. Così il rinnovo eredita prenotazione, coda, stalli, personale e notizie
|
||||
dell'officina (ADR 0009), il client non ha un comando in più e il protocollo dei comandi non cambia.
|
||||
Il validatore pretende esattamente un intervento con effetto `renew`.
|
||||
@@ -97,8 +106,9 @@ Mancava:
|
||||
8. **Quadro della flotta.** `FleetOutlook` (Core, sola lettura): era in corso e prossima, veicoli della
|
||||
compagnia (età, vita, condizione, in produzione, superato e da quando, successore consigliato, valore
|
||||
di libro, rivendita, fattore di manutenzione), catalogo dei soli modelli in produzione con il segno dei
|
||||
superati e l'ultimo anno di produzione, treni da rinnovare con la spesa netta e se la cassa basta.
|
||||
Protocollo: `DetailKind.Fleet` (10) e `FleetReport` (136) su richiesta, `ClientWorld.Fleet`.
|
||||
superati e l'ultimo anno di produzione, treni da rinnovare con la spesa netta, se la cassa basta al
|
||||
netto degli altri rinnovi prenotati e se il rinnovo è già prenotato (il client mostra «rinnovo
|
||||
prenotato» al posto di «Rinnova»). `era` e `nextEra` sono id di `eras.json`; il client mostra il nome. Protocollo: `DetailKind.Fleet` (10) e `FleetReport` (136) su richiesta, `ClientWorld.Fleet`.
|
||||
9. **Client.** Nessun calcolo: il pannello Treni prende il catalogo dal quadro (nasconde i fuori
|
||||
produzione, segna i superati con il successore e, per il modello scelto, prestazioni e prezzo del
|
||||
successore e l'ultimo anno di produzione), mostra «superato · rivendita X» sui veicoli liberi, ha
|
||||
@@ -108,17 +118,31 @@ Mancava:
|
||||
veicoli superati con successore, valori e manutenzione, treni da rinnovare con «Rinnova»). Il quadro si
|
||||
chiede all'apertura, a ogni nuovo giorno e dopo i comandi. Testi in `strings.csv`.
|
||||
10. **IA.** Due regole deterministiche:
|
||||
- all'acquisto per un progetto, un modello uscito di produzione si sostituisce con il successore
|
||||
consigliato o, se non c'è, con il migliore dell'anno (`Estimators`);
|
||||
- all'acquisto per un progetto, un modello superato passa al successore consigliato se questo non ha
|
||||
sforzo di trazione, potenza o velocità inferiori (`Obsolescence.NoWorseThan`), così i treni
|
||||
aggiuntivi non nascono superati per poi essere rinnovati dopo pochi anni; un modello uscito di
|
||||
produzione senza un tale successore passa al migliore dell'anno (`Estimators`), che a sua volta
|
||||
scarta i carri e le carrozze superati con un successore in produzione non peggiore (dal 1950 le
|
||||
linee passeggeri nuove hanno la carrozza moderna);
|
||||
- ogni mese, dopo la crescita delle linee, al massimo `renewal.maxTrainsPerMonth` (1) treni in linea,
|
||||
sani e non in officina, in ordine di id, si mandano al rinnovo se almeno un veicolo è superato da
|
||||
`minSupersededYears` (3) anni o ha `minAgeShareOfLife` (50 %) della vita, e se dopo la spesa netta
|
||||
resta in cassa `cashReserveMultiple` (2) volte la riserva dell'agente. Parametri nel blocco
|
||||
`renewal` di `ai.json`.
|
||||
`minSupersededYears` (3) anni o ha `minAgeShareOfLife` (50 %) della vita, se il rinnovo non
|
||||
peggiora il treno (sforzo di trazione, potenza, velocità massima e rapporto potenza/massa almeno
|
||||
quelli di oggi: `Obsolescence.KeepsPerformance`) e se dopo la spesa (successori − rivendite +
|
||||
lavoro) resta in cassa libera `cashReserveMultiple` (2) volte la riserva dell'agente. Parametri nel
|
||||
blocco `renewal` di `ai.json`. La cassa libera è la cassa meno la spesa impegnata dai rinnovi
|
||||
prenotati e non ancora avviati: la usano anche borsa, acquisto d'industrie, nuovi progetti e treni,
|
||||
così lo stesso mese non spende due volte la stessa cassa.
|
||||
11. **F7.** Le ere continue e la ricerca aggiungeranno modelli e successori ai dati o anticiperanno
|
||||
`eraFrom` per compagnia: `Obsolescence` ed `EraSystem` leggono solo dati e anno, quindi basterà
|
||||
passare loro l'anno «tecnologico» della compagnia al posto di quello del calendario.
|
||||
|
||||
12. **Ricostruzione dopo un deragliamento.** L'intervento «replace» rimette i componenti a nuovo, ma
|
||||
l'età contabile (`BoughtDay`) riparte solo se il modello è ancora in produzione: un modello che non si
|
||||
compra più non torna nuovo nel patrimonio per il 45 % del prezzo; l'usura riparte comunque da capo
|
||||
(il fattore d'età torna a 1). Un modello superato ma ancora in produzione si comporta come uno nuovo
|
||||
comprato oggi, che `BuyVehicle` consente.
|
||||
|
||||
## Conseguenze
|
||||
|
||||
- Il patrimonio netto scende di più per chi tiene modelli superati; la scalata e il rating lo vedono.
|
||||
@@ -137,3 +161,9 @@ Mancava:
|
||||
l'usura.
|
||||
- Le IA rinnovano solo treni in linea e non vendono i veicoli liberi in deposito.
|
||||
- Il successore è unico per modello: niente rami (per esempio vapore → diesel o elettrica).
|
||||
- Il successore non è sempre migliore in tutto, e la scelta è voluta: la Vittoria 2-8-0 (110 kN) passa
|
||||
alla Freccia 4-6-2 (95 kN, ma 1150 kW e 110 km/h); la Freccia passa all'Aquila D1 (950 kW, 100 km/h,
|
||||
ma 180 kN, costo d'esercizio minore e trazione diesel che resta in produzione fino al 1975); la carrozza
|
||||
moderna porta più posti con più massa. Il giocatore vede prestazioni e prezzo del successore prima di
|
||||
rinnovare; le IA non rinnovano e non cambiano modello quando il treno peggiorerebbe.
|
||||
- Il piano del rinnovo è quello del giorno dell'avvio, non quello della prenotazione (vedi il punto 5).
|
||||
@@ -17,8 +17,11 @@ public sealed record FleetVehicleLine(
|
||||
/// <summary>Modello in produzione nell'anno, come lo mostra il catalogo d'acquisto: superato o no e successore consigliato.</summary>
|
||||
public sealed record VehicleModelLine(VehicleDef Def, bool Superseded, int? SupersededYear, VehicleDef? Successor, int? LastYear);
|
||||
|
||||
/// <summary>Treno con veicoli da rinnovare: quanti, spesa netta del rinnovo (successori − rivendite + lavoro) e se la cassa basta.</summary>
|
||||
public sealed record RenewalTrainLine(TrainId Train, int Vehicles, Money NetCost, bool Affordable);
|
||||
/// <summary>
|
||||
/// Treno con veicoli da rinnovare: quanti, spesa netta del rinnovo (successori − rivendite + lavoro), se la
|
||||
/// cassa basta al netto degli altri rinnovi prenotati e se il rinnovo è già prenotato (in viaggio o in coda all'officina).
|
||||
/// </summary>
|
||||
public sealed record RenewalTrainLine(TrainId Train, int Vehicles, Money NetCost, bool Affordable, bool Booked);
|
||||
|
||||
/// <summary>
|
||||
/// Quadro del rinnovo della flotta (F6, ADR 0020), in sola lettura: era in corso e prossima, veicoli
|
||||
@@ -69,14 +72,17 @@ public sealed class FleetOutlook
|
||||
}
|
||||
var trains = new List<RenewalTrainLine>();
|
||||
var c = company.IsValid && company.Value < w.Companies.Count ? w.Companies[company.Value] : null;
|
||||
int renew = d.Maintenance.Interventions.FindIndex(i => i.Effect == InterventionEffect.Renew);
|
||||
// la cassa disponibile per un rinnovo esclude la spesa impegnata dagli altri già prenotati
|
||||
var committed = Obsolescence.Committed(w, company);
|
||||
foreach (var t in w.Trains)
|
||||
{
|
||||
if (t.Removed || t.Owner != company) continue;
|
||||
var plan = Obsolescence.RenewalPlan(w, t);
|
||||
if (plan.Count == 0) continue;
|
||||
var net = Obsolescence.NetCost(plan) + Fleet.CostOf(w, t, d.Maintenance.Interventions[renew], Fleet.PolicyOf(w, t));
|
||||
trains.Add(new RenewalTrainLine(t.Id, plan.Count, net, c is not null && (!net.IsPositive || c.Cash >= net)));
|
||||
var net = Obsolescence.RenewalCost(w, t, plan);
|
||||
var available = c is null ? Money.Zero : c.Cash - (committed - Obsolescence.Commitment(w, t));
|
||||
trains.Add(new RenewalTrainLine(t.Id, plan.Count, net, c is not null && (!net.IsPositive || available >= net),
|
||||
Obsolescence.RenewalBooked(w, t)));
|
||||
}
|
||||
return new FleetOutlook
|
||||
{
|
||||
|
||||
@@ -196,7 +196,7 @@ internal sealed class AiAgent
|
||||
var loco = _w.Data.Vehicle(project.Loco);
|
||||
var car = _w.Data.Vehicle(project.Car);
|
||||
long price = Estimators.TrainPrice(loco, car, project.CarsPerTrain);
|
||||
if (_c.Cash.Cents < price + Reserve() / 2 && !Borrow(price + Reserve() / 2 - _c.Cash.Cents, completing: project.Trains.Count == 0)) return false;
|
||||
if (FreeCash() < price + Reserve() / 2 && !Borrow(price + Reserve() / 2 - FreeCash(), completing: project.Trains.Count == 0)) return false;
|
||||
var ids = new List<VehicleId>();
|
||||
var rl = Do(new BuyVehicleCommand(project.Loco, project.Depot, 1));
|
||||
if (!rl.Ok) return false;
|
||||
@@ -213,21 +213,27 @@ internal sealed class AiAgent
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Modelli fuori produzione (ADR 0020): la linea passa al successore consigliato o, se la catena non
|
||||
/// ne offre, al modello che l'IA sceglierebbe oggi per un progetto nuovo. Così i treni aggiuntivi non
|
||||
/// chiedono veicoli che non si possono più comprare.
|
||||
/// Modelli superati o fuori produzione (ADR 0020): la linea passa al successore consigliato appena il
|
||||
/// modello è superato, se il successore non ha trazione, potenza o velocità inferiori (comprarlo nuovo
|
||||
/// vorrebbe dire perdere subito valore, pagare di più la manutenzione e rinnovarlo dopo pochi anni)
|
||||
/// o, se è fuori produzione e la catena non offre un tale successore, al modello che l'IA sceglierebbe
|
||||
/// oggi per un progetto nuovo. Così i treni aggiuntivi non nascono superati.
|
||||
/// </summary>
|
||||
private void UpdateModels(AiProject project)
|
||||
{
|
||||
int year = _ctx.Year;
|
||||
var loco = _w.Data.Vehicle(project.Loco);
|
||||
if (!Obsolescence.InProduction(loco, year) && (Obsolescence.Recommended(loco, year) ?? Estimators.BestLocomotive(_w, year)) is { } newLoco)
|
||||
project.Loco = newLoco.Id;
|
||||
var newLoco = Obsolescence.IsSuperseded(loco, year) && Obsolescence.Recommended(loco, year) is { } rec && Obsolescence.NoWorseThan(rec, loco) ? rec : null;
|
||||
if (newLoco is null && !Obsolescence.InProduction(loco, year)) newLoco = Estimators.BestLocomotive(_w, year);
|
||||
if (newLoco is not null) project.Loco = newLoco.Id;
|
||||
var car = _w.Data.Vehicle(project.Car);
|
||||
if (Obsolescence.InProduction(car, year)) return;
|
||||
var newCar = Obsolescence.Recommended(car, year) ?? (car.Kind == VehicleKind.Coach
|
||||
? Estimators.CoachFor(_w, car.Class ?? PaxClass.Worker, year)
|
||||
: project.Good >= 0 ? Estimators.WagonFor(_w, project.Good, year) : null);
|
||||
var newCar = Obsolescence.IsSuperseded(car, year) && Obsolescence.Recommended(car, year) is { } recCar && Obsolescence.NoWorseThan(recCar, car) ? recCar : null;
|
||||
if (newCar is null && !Obsolescence.InProduction(car, year))
|
||||
{
|
||||
newCar = car.Kind == VehicleKind.Coach
|
||||
? Estimators.CoachFor(_w, car.Class ?? PaxClass.Worker, year)
|
||||
: project.Good >= 0 ? Estimators.WagonFor(_w, project.Good, year) : null;
|
||||
}
|
||||
if (newCar is not null) project.Car = newCar.Id;
|
||||
}
|
||||
|
||||
@@ -308,7 +314,7 @@ internal sealed class AiAgent
|
||||
sources.Sort((a, b) => a.Km != b.Km ? a.Km.CompareTo(b.Km) : a.Key.CompareTo(b.Key));
|
||||
var loco = Estimators.BestLocomotive(_w, _ctx.Year);
|
||||
if (loco is null) return false;
|
||||
long budget = _c.Cash.Cents - Reserve() / 2 + LoanRoom();
|
||||
long budget = FreeCash() - Reserve() / 2 + LoanRoom();
|
||||
int tried = 0;
|
||||
foreach (var (pos, key, km) in sources)
|
||||
{
|
||||
@@ -336,6 +342,12 @@ internal sealed class AiAgent
|
||||
return false;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Cassa libera: la cassa meno la spesa impegnata dai rinnovi prenotati e non ancora avviati, che si
|
||||
/// paga giorni dopo a officina avviata (ADR 0020). Gli investimenti guardano questa, non la cassa intera.
|
||||
/// </summary>
|
||||
private long FreeCash() => _c.Cash.Cents - Obsolescence.Committed(_w, _c.Id).Cents;
|
||||
|
||||
/// <summary>Riserva di cassa: mesi di costi d'esercizio stimati dalla flotta e dalla rete.</summary>
|
||||
private long Reserve()
|
||||
{
|
||||
@@ -428,15 +440,16 @@ internal sealed class AiAgent
|
||||
/// Manda in officina per il rinnovo (intervento «renew», lo stesso comando ScheduleService del
|
||||
/// giocatore) al più renewal.maxTrainsPerMonth treni in servizio, in ordine di id, che hanno un
|
||||
/// veicolo superato da almeno renewal.minSupersededYears anni o con almeno renewal.minAgeShareOfLife
|
||||
/// della vita utile, se dopo la spesa netta (successori − rivendite) la cassa resta sopra
|
||||
/// renewal.cashReserveMultiple volte la riserva.
|
||||
/// della vita utile, se il rinnovo non peggiora le prestazioni del treno
|
||||
/// (<see cref="Obsolescence.KeepsPerformance"/>) e se dopo la spesa (successori − rivendite + lavoro)
|
||||
/// la cassa libera resta sopra renewal.cashReserveMultiple volte la riserva. La spesa resta impegnata
|
||||
/// (<see cref="FreeCash"/>) fino all'avvio dei lavori, così gli investimenti dello stesso mese non la riusano.
|
||||
/// </summary>
|
||||
private void RenewFleet()
|
||||
{
|
||||
var r = _w.Data.Ai.Renewal;
|
||||
if (r.MaxTrainsPerMonth <= 0) return;
|
||||
var interventions = _w.Data.Maintenance.Interventions;
|
||||
string renewal = interventions[interventions.FindIndex(i => i.Effect == InterventionEffect.Renew)].Id;
|
||||
string renewal = _w.Data.Maintenance.Interventions[Obsolescence.RenewalIntervention(_w.Data)].Id;
|
||||
double daysPerYear = _w.Calendar.DaysPerYear;
|
||||
int scheduled = 0;
|
||||
foreach (var t in _w.Trains)
|
||||
@@ -456,9 +469,9 @@ internal sealed class AiAgent
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (!due) continue;
|
||||
long net = Obsolescence.NetCost(plan).Cents;
|
||||
if (_c.Cash.Cents - net < (long)(Reserve() * r.CashReserveMultiple)) continue;
|
||||
if (!due || !Obsolescence.KeepsPerformance(_w, t, plan)) continue;
|
||||
long net = Obsolescence.RenewalCost(_w, t, plan).Cents;
|
||||
if (FreeCash() - net < (long)(Reserve() * r.CashReserveMultiple)) continue;
|
||||
if (Do(new ScheduleServiceCommand(t.Id, renewal)).Ok) scheduled++;
|
||||
}
|
||||
}
|
||||
@@ -474,13 +487,13 @@ internal sealed class AiAgent
|
||||
if (other.Defunct || other.ControlledBy != _c.Id || other.IsPlayer) continue;
|
||||
if (_ctx.Day - other.ControlSinceDay < sm.MergeAfterDays) continue;
|
||||
double minority = (other.Shares.Outstanding - other.Shares.Of(_c.Id)) * other.SharePrice;
|
||||
if (_c.Cash.Cents > minority + Reserve()) Do(new MergeCompanyCommand(other.Id));
|
||||
if (FreeCash() > minority + Reserve()) Do(new MergeCompanyCommand(other.Id));
|
||||
}
|
||||
if (!_p.BuysShares) return;
|
||||
// la Predatoria accumula quote dei concorrenti quotati (prima il giocatore) e poi lancia l'offerta;
|
||||
// solo con una rete che rende e cassa abbondante, e solo in compagnie in utile
|
||||
if (!_s.Projects.Any(p => p.Stage == AiProjectStage.Running) || _c.AnnualProfit <= 0) return;
|
||||
long budget = (long)(Math.Max(0, _c.Cash.Cents - 3 * Reserve()) * _mk.SharesCashShare);
|
||||
long budget = (long)(Math.Max(0, FreeCash() - 3 * Reserve()) * _mk.SharesCashShare);
|
||||
if (budget <= 0) return;
|
||||
foreach (var target in _w.Companies.OrderByDescending(t => t.IsPlayer).ThenBy(t => t.Id.Value))
|
||||
{
|
||||
@@ -514,7 +527,7 @@ internal sealed class AiAgent
|
||||
long needed = (long)Math.Ceiling(goal * target.Shares.Outstanding) - target.Shares.Of(_c.Id);
|
||||
if (needed <= 0) return false;
|
||||
double cost = (double)needed * price;
|
||||
if (_c.Cash.Cents < cost * _mk.BidCashMultiple + Reserve()) return false;
|
||||
if (FreeCash() < cost * _mk.BidCashMultiple + Reserve()) return false;
|
||||
return Do(new LaunchBidCommand(target.Id, new Money(price), goal)).Ok;
|
||||
}
|
||||
|
||||
@@ -567,7 +580,7 @@ internal sealed class AiAgent
|
||||
private void BuyIndustries()
|
||||
{
|
||||
if (!Tiers.Unlocks(_w, _c).BuyIndustry || _s.LastIndustryYear == _ctx.Year) return;
|
||||
long budget = (long)(Math.Max(0, _c.Cash.Cents - Reserve()) * _mk.IndustryMaxCashShare);
|
||||
long budget = (long)(Math.Max(0, FreeCash() - Reserve()) * _mk.IndustryMaxCashShare);
|
||||
if (budget <= 0) return;
|
||||
var served = Tiers.ServedStations(_w, _c.Id);
|
||||
Industry? best = null;
|
||||
@@ -633,7 +646,7 @@ internal sealed class AiAgent
|
||||
{
|
||||
int open = _s.Projects.Count(p => p.Stage is AiProjectStage.Construction or AiProjectStage.Equip);
|
||||
if (open >= _plan.MaxConcurrentProjects) return;
|
||||
long budget = _c.Cash.Cents - Reserve() + LoanRoom();
|
||||
long budget = FreeCash() - Reserve() + LoanRoom();
|
||||
if (budget <= 0) return;
|
||||
var loco = Estimators.BestLocomotive(_w, _ctx.Year);
|
||||
if (loco is null) return;
|
||||
@@ -1209,7 +1222,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() - _c.Cash.Cents;
|
||||
long need = p.Capital + Reserve() - FreeCash();
|
||||
if (need > 0 && !Borrow(need)) return;
|
||||
var cand = p.Candidate;
|
||||
var stationA = p.ExistingA;
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
using RailEnterprise.Core.Common;
|
||||
using RailEnterprise.Core.Data;
|
||||
using RailEnterprise.Core.Economy;
|
||||
using RailEnterprise.Core.Simulation.Systems;
|
||||
|
||||
namespace RailEnterprise.Core.Simulation;
|
||||
|
||||
@@ -64,26 +65,33 @@ public static class Estimators
|
||||
return best;
|
||||
}
|
||||
|
||||
/// <summary>Carro più economico che trasporta il bene nell'anno.</summary>
|
||||
/// <summary>
|
||||
/// Vero se il modello è superato e il suo successore consigliato si compra e non è peggiore: chi sceglie
|
||||
/// un modello nuovo (IA, stime) lo scarta per non comprare un veicolo che perde subito valore (ADR 0020).
|
||||
/// </summary>
|
||||
private static bool Outdated(VehicleDef v, int year) =>
|
||||
Obsolescence.IsSuperseded(v, year) && Obsolescence.Recommended(v, year) is { } next && Obsolescence.NoWorseThan(next, v);
|
||||
|
||||
/// <summary>Carro più economico che trasporta il bene nell'anno, esclusi i superati con un successore in produzione.</summary>
|
||||
public static VehicleDef? WagonFor(World w, int good, int year)
|
||||
{
|
||||
VehicleDef? best = null;
|
||||
foreach (var v in w.Data.Vehicles)
|
||||
{
|
||||
if (v.Kind != VehicleKind.Wagon || v.EraFrom > year || (v.EraTo is { } to && year > to)) continue;
|
||||
if (v.Kind != VehicleKind.Wagon || v.EraFrom > year || (v.EraTo is { } to && year > to) || Outdated(v, year)) continue;
|
||||
if (Array.IndexOf(v.GoodIndices, good) < 0) continue;
|
||||
if (best is null || v.Price < best.Price) best = v;
|
||||
}
|
||||
return best;
|
||||
}
|
||||
|
||||
/// <summary>Carrozza della classe indicata disponibile nell'anno.</summary>
|
||||
/// <summary>Carrozza più economica della classe indicata disponibile nell'anno, esclusi i superati con un successore in produzione.</summary>
|
||||
public static VehicleDef? CoachFor(World w, PaxClass cls, int year)
|
||||
{
|
||||
VehicleDef? best = null;
|
||||
foreach (var v in w.Data.Vehicles)
|
||||
{
|
||||
if (v.Kind != VehicleKind.Coach || v.Class != cls || v.EraFrom > year || (v.EraTo is { } to && year > to)) continue;
|
||||
if (v.Kind != VehicleKind.Coach || v.Class != cls || v.EraFrom > year || (v.EraTo is { } to && year > to) || Outdated(v, year)) continue;
|
||||
if (best is null || v.Price < best.Price) best = v;
|
||||
}
|
||||
return best;
|
||||
|
||||
@@ -83,11 +83,16 @@ public static class MaintenanceCommandHandlers
|
||||
var def = m.Interventions[idx];
|
||||
if (def.Effect == InterventionEffect.Renew)
|
||||
{
|
||||
// rinnovo (ADR 0020): serve almeno un veicolo superato con un successore in produzione e la cassa per la spesa netta
|
||||
// rinnovo (ADR 0020): serve almeno un veicolo superato con un successore in produzione e la cassa
|
||||
// per la spesa netta, al netto degli altri rinnovi già prenotati; all'avvio dei lavori si ricontrolla
|
||||
var plan = Obsolescence.RenewalPlan(w, train);
|
||||
if (plan.Count == 0) return reply(CommandError.NotAllowed, $"{train.Name}: nessun veicolo superato da rinnovare");
|
||||
var net = Obsolescence.NetCost(plan) + Fleet.CostOf(w, train, def, Fleet.PolicyOf(w, train));
|
||||
if (net.IsPositive && company.Cash < net) return reply(CommandError.InsufficientFunds, $"Il rinnovo di {train.Name} costa {net} al netto delle rivendite: cassa insufficiente");
|
||||
var net = Obsolescence.RenewalCost(w, train, plan);
|
||||
var committed = Obsolescence.Committed(w, company.Id, train);
|
||||
if (net.IsPositive && company.Cash - committed < net)
|
||||
return reply(CommandError.InsufficientFunds, committed.IsPositive
|
||||
? $"Il rinnovo di {train.Name} costa {net} al netto delle rivendite: cassa insufficiente (già impegnati {committed} in altri rinnovi)"
|
||||
: $"Il rinnovo di {train.Name} costa {net} al netto delle rivendite: cassa insufficiente");
|
||||
}
|
||||
int parts = Fleet.PartsFor(w, train, def);
|
||||
FleetMaintenanceSystem.CancelBooking(train);
|
||||
|
||||
@@ -53,7 +53,7 @@ public sealed class EraSystem : ISimSystem
|
||||
var e = new GameEvent(w.Clock.Day, EventKind.Technology, EventSeverity.Opportunity, text, Company: CompanyId.None);
|
||||
w.Events.Add(e);
|
||||
if (w.Companies.Count > 0)
|
||||
Corporate.Milestone(w, w.Player, era is not null ? $"inizia l'{era.NameIt}" : $"novità del {year}: {Join(Unlocks(w.Data, year).Select(u => u.TextIt))}");
|
||||
Corporate.Milestone(w, w.Player, era is not null ? $"inizia l'{era.NameIt}" : $"novità del {year}: {string.Join("; ", NewsParts(w.Data, year))}");
|
||||
return e;
|
||||
}
|
||||
|
||||
@@ -126,17 +126,24 @@ public sealed class EraSystem : ISimSystem
|
||||
public static string? NewsText(GameData d, int year)
|
||||
{
|
||||
var era = EraStarting(d, year);
|
||||
var parts = NewsParts(d, year);
|
||||
if (era is null && parts.Count == 0) return null;
|
||||
string head = era is not null ? $"Inizia l'{era.NameIt} ({year})" : $"Novità del {year}";
|
||||
return parts.Count == 0 ? head : $"{head}: {string.Join("; ", parts)}";
|
||||
}
|
||||
|
||||
/// <summary>Parti della notizia dell'anno: sblocchi, modelli superati, fuori produzione (vuota se nessuna).</summary>
|
||||
public static List<string> NewsParts(GameData d, int year)
|
||||
{
|
||||
var unlocks = Unlocks(d, year);
|
||||
var retired = Retired(d, year);
|
||||
var superseded = NewlySuperseded(d, year);
|
||||
if (era is null && unlocks.Count == 0 && retired.Count == 0 && superseded.Count == 0) return null;
|
||||
var parts = new List<string>();
|
||||
if (unlocks.Count > 0) parts.Add($"sblocca {Join(unlocks.Select(u => u.TextIt))}");
|
||||
if (superseded.Count > 0)
|
||||
parts.Add($"{(superseded.Count == 1 ? "modello superato" : "modelli superati")}: {Join(superseded.Select(v => $"{v.NameIt} (successore {v.SuccessorDef!.NameIt})"))}");
|
||||
if (retired.Count > 0) parts.Add($"fuori produzione: {Join(retired.Select(v => v.NameIt))}");
|
||||
string head = era is not null ? $"Inizia l'{era.NameIt} ({year})" : $"Novità del {year}";
|
||||
return parts.Count == 0 ? head : $"{head}: {string.Join("; ", parts)}";
|
||||
return parts;
|
||||
}
|
||||
|
||||
private static string Join(IEnumerable<string> items)
|
||||
|
||||
@@ -200,12 +200,8 @@ public static class Fleet
|
||||
var m = w.Data.Maintenance;
|
||||
long today = w.Clock.Day;
|
||||
double ef = policy.EffectFactor;
|
||||
if (def.Effect == InterventionEffect.Renew)
|
||||
{
|
||||
// rinnovo: i veicoli superati si vendono e al loro posto entrano i successori nuovi (ADR 0020)
|
||||
Obsolescence.Renew(w, t);
|
||||
return;
|
||||
}
|
||||
// rinnovo: i veicoli superati si sono già sostituiti all'avvio dei lavori, quando si è pagato (ADR 0020)
|
||||
if (def.Effect == InterventionEffect.Renew) return;
|
||||
foreach (var id in t.Vehicles)
|
||||
{
|
||||
var v = w.Vehicles[id.Value];
|
||||
@@ -239,11 +235,17 @@ public static class Fleet
|
||||
Raise(v, t.FailedComponent, def.RestoreTo ?? 100, ef);
|
||||
break;
|
||||
case InterventionEffect.Replace:
|
||||
// veicolo sostituito: nuovo di fabbrica
|
||||
// veicolo ricostruito: componenti nuovi di fabbrica. L'età contabile riparte solo se il
|
||||
// modello è ancora in produzione: un modello che non si compra più non torna nuovo nel
|
||||
// patrimonio (ADR 0020), l'usura però riparte da capo
|
||||
for (int j = 0; j < v.Components.Length; j++) v.Components[j] = 100;
|
||||
v.BoughtDay = today;
|
||||
if (Obsolescence.InProduction(v.Def, w.Clock.Year))
|
||||
{
|
||||
v.BoughtDay = today;
|
||||
v.AgeFactorOffset = 0;
|
||||
}
|
||||
else v.AgeFactorOffset = Math.Max(0, RawAgeFactor(m.Wear, v, today, w.Calendar.DaysPerYear) - 1);
|
||||
v.OdometerKm = 0;
|
||||
v.AgeFactorOffset = 0;
|
||||
Array.Clear(v.WearEma);
|
||||
MarkInspection(v, today);
|
||||
MarkService(v, today);
|
||||
|
||||
@@ -489,7 +489,13 @@ public sealed class FleetMaintenanceSystem : ISimSystem
|
||||
waitingParts = true;
|
||||
continue;
|
||||
}
|
||||
Start(ctx, d, job, t, rate);
|
||||
if (!Start(ctx, d, job, t, rate))
|
||||
{
|
||||
// rinnovo annullato all'avvio: il treno esce dall'officina senza lavori
|
||||
d.Jobs.RemoveAt(i--);
|
||||
inStall--;
|
||||
continue;
|
||||
}
|
||||
}
|
||||
job.Progress += rate;
|
||||
if (job.Progress + 1e-9 < job.Days) continue;
|
||||
@@ -507,19 +513,50 @@ public sealed class FleetMaintenanceSystem : ISimSystem
|
||||
else if (!waitingParts) d.PartsAlerted = false;
|
||||
}
|
||||
|
||||
private static void Start(WorldContext ctx, Depot d, WorkshopJob job, Train t, double rate)
|
||||
/// <summary>Avvia il lavoro: preleva i ricambi e paga l'intervento. Falso se un rinnovo si annulla.</summary>
|
||||
private static bool Start(WorldContext ctx, Depot d, WorkshopJob job, Train t, double rate)
|
||||
{
|
||||
var w = ctx.World;
|
||||
var m = w.Data.Maintenance;
|
||||
var def = m.Interventions[job.Intervention];
|
||||
var cost = Fleet.CostOf(w, t, def, Fleet.PolicyOf(w, t));
|
||||
List<RenewalItem>? plan = null;
|
||||
if (def.Effect == InterventionEffect.Renew)
|
||||
{
|
||||
// rinnovo (ADR 0020): piano, spesa e cassa si controllano qui, quando si paga, non solo alla
|
||||
// prenotazione: tra le due l'anno può cambiare il piano e la cassa può essersi spesa altrove
|
||||
plan = Obsolescence.RenewalPlan(w, t);
|
||||
var total = Obsolescence.NetCost(plan) + cost;
|
||||
var company = w.Companies[t.Owner.Value];
|
||||
string? why = plan.Count == 0 ? "nessun veicolo superato con un successore in produzione"
|
||||
: total.IsPositive && company.Cash < total ? $"cassa insufficiente per la spesa netta di {total}" : null;
|
||||
if (why is not null)
|
||||
{
|
||||
t.InWorkshop = false;
|
||||
t.MaintenanceDepot = DepotId.None;
|
||||
t.PlannedIntervention = -1;
|
||||
w.Events.Add(new GameEvent(ctx.Day, EventKind.Maintenance, EventSeverity.Warning,
|
||||
$"{t.Name}: rinnovo annullato a {d.Name}, {why}", EntityKind.Train, t.Id.Value, t.Owner));
|
||||
return false;
|
||||
}
|
||||
}
|
||||
d.SpareParts -= job.Parts;
|
||||
w.Goods.Consumed[w.Data.SparePartsGood] += job.Parts;
|
||||
var cost = Fleet.CostOf(w, t, def, Fleet.PolicyOf(w, t));
|
||||
if (cost.IsPositive) w.Money.Transfer(Account.Of(t.Owner), Account.External, cost, LedgerEntry.FleetMaintenance);
|
||||
job.CostCents = cost.Cents;
|
||||
job.Started = true;
|
||||
t.MaintenanceThisYear += cost.Cents;
|
||||
if (plan is not null)
|
||||
{
|
||||
// i veicoli si sostituiscono all'avvio, con il piano appena pagato; i giorni d'officina sono la messa in servizio
|
||||
var net = Obsolescence.NetCost(plan);
|
||||
int renewed = Obsolescence.Renew(w, t, plan);
|
||||
string what = renewed == 1 ? "1 veicolo sostituito" : $"{renewed} veicoli sostituiti";
|
||||
w.Events.Add(new GameEvent(ctx.Day, EventKind.Maintenance, EventSeverity.Info,
|
||||
$"{t.Name}: rinnovo avviato a {d.Name}, {what} (spesa netta {net + cost})", EntityKind.Train, t.Id.Value, t.Owner));
|
||||
}
|
||||
if (job.Days / rate >= m.Planner.ReserveMinDays) Cover(ctx, t, d);
|
||||
return true;
|
||||
}
|
||||
|
||||
private static void Complete(WorldContext ctx, Depot d, WorkshopJob job, Train t)
|
||||
@@ -527,7 +564,6 @@ public sealed class FleetMaintenanceSystem : ISimSystem
|
||||
var w = ctx.World;
|
||||
var m = w.Data.Maintenance;
|
||||
var def = m.Interventions[job.Intervention];
|
||||
int renewed = def.Effect == InterventionEffect.Renew ? Obsolescence.RenewalPlan(w, t).Count : 0;
|
||||
Fleet.Apply(w, t, def, Fleet.PolicyOf(w, t));
|
||||
bool repair = def.Effect is InterventionEffect.Repair or InterventionEffect.Replace;
|
||||
if (def.Effect != InterventionEffect.Inspection)
|
||||
@@ -552,9 +588,8 @@ public sealed class FleetMaintenanceSystem : ISimSystem
|
||||
}
|
||||
else if (def.Effect == InterventionEffect.Renew)
|
||||
{
|
||||
string what = renewed == 1 ? "1 veicolo sostituito" : $"{renewed} veicoli sostituiti";
|
||||
w.Events.Add(new GameEvent(ctx.Day, EventKind.Maintenance, EventSeverity.Info,
|
||||
$"{t.Name}: rinnovo completato a {d.Name}, {what}", EntityKind.Train, t.Id.Value, t.Owner));
|
||||
$"{t.Name}: rinnovo completato a {d.Name}", EntityKind.Train, t.Id.Value, t.Owner));
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -116,16 +116,85 @@ public static class Obsolescence
|
||||
return new Money(cents);
|
||||
}
|
||||
|
||||
/// <summary>Indice in maintenance.json dell'intervento con effetto «renew» (il validatore ne garantisce uno).</summary>
|
||||
public static int RenewalIntervention(GameData d) => d.Maintenance.Interventions.FindIndex(i => i.Effect == InterventionEffect.Renew);
|
||||
|
||||
/// <summary>Spesa complessiva del rinnovo del treno oggi: successori − rivendite + lavoro dell'officina.</summary>
|
||||
public static Money RenewalCost(World w, Train t, List<RenewalItem> plan) =>
|
||||
NetCost(plan) + Fleet.CostOf(w, t, w.Data.Maintenance.Interventions[RenewalIntervention(w.Data)], Fleet.PolicyOf(w, t));
|
||||
|
||||
/// <summary>Vero se il treno ha un rinnovo prenotato o in officina.</summary>
|
||||
public static bool RenewalBooked(World w, Train t) => t.PlannedIntervention >= 0 && t.PlannedIntervention == RenewalIntervention(w.Data);
|
||||
|
||||
/// <summary>
|
||||
/// Rinnovo in officina (intervento con effetto «renew»): ogni veicolo superato del treno si vende al
|
||||
/// valore di rivendita (voce «vendita di treni») e al suo posto, nella stessa posizione della
|
||||
/// composizione, entra un veicolo nuovo del successore consigliato (voce «acquisto di treni»). I
|
||||
/// veicoli venduti restano nell'elenco con <c>Sold</c>, come quelli di <c>SellVehicle</c>.
|
||||
/// Restituisce quanti veicoli sono stati sostituiti.
|
||||
/// Spesa impegnata dal rinnovo prenotato del treno e non ancora pagata: la spesa di oggi (se positiva)
|
||||
/// finché i lavori non partono. All'avvio i veicoli si sostituiscono e il piano si svuota, quindi un
|
||||
/// rinnovo già pagato non impegna più nulla.
|
||||
/// </summary>
|
||||
public static int Renew(World w, Train t)
|
||||
public static Money Commitment(World w, Train t)
|
||||
{
|
||||
if (t.Removed || !RenewalBooked(w, t)) return Money.Zero;
|
||||
var plan = RenewalPlan(w, t);
|
||||
if (plan.Count == 0) return Money.Zero;
|
||||
var cost = RenewalCost(w, t, plan);
|
||||
return cost.IsPositive ? cost : Money.Zero;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Spesa impegnata dai rinnovi prenotati della compagnia e non ancora avviati, escluso eventualmente
|
||||
/// un treno: va tolta dalla cassa prima di prenotarne un altro o di investire (ADR 0020).
|
||||
/// </summary>
|
||||
public static Money Committed(World w, CompanyId company, Train? except = null)
|
||||
{
|
||||
long cents = 0;
|
||||
foreach (var t in w.Trains)
|
||||
{
|
||||
if (t != except && t.Owner == company) cents += Commitment(w, t).Cents;
|
||||
}
|
||||
return new Money(cents);
|
||||
}
|
||||
|
||||
/// <summary>Vero se il modello <paramref name="next"/> non ha sforzo di trazione, potenza o velocità massima inferiori a <paramref name="old"/>.</summary>
|
||||
public static bool NoWorseThan(VehicleDef next, VehicleDef old) =>
|
||||
next.TractiveEffortKn >= old.TractiveEffortKn && next.PowerKw >= old.PowerKw && next.MaxSpeedKmh >= old.MaxSpeedKmh;
|
||||
|
||||
/// <summary>
|
||||
/// Vero se il rinnovo non peggiora le prestazioni del treno: sforzo di trazione, potenza, velocità
|
||||
/// massima e rapporto potenza/massa restano almeno quelli di oggi. Le IA rinnovano solo così; il
|
||||
/// giocatore vede il successore con le sue prestazioni e decide da sé.
|
||||
/// </summary>
|
||||
public static bool KeepsPerformance(World w, Train t, List<RenewalItem> plan)
|
||||
{
|
||||
double te = 0, power = 0, mass = 0, vmax = double.MaxValue;
|
||||
double te2 = 0, power2 = 0, mass2 = 0, vmax2 = double.MaxValue;
|
||||
foreach (var id in t.Vehicles)
|
||||
{
|
||||
var def = w.Vehicles[id.Value].Def;
|
||||
var next = def;
|
||||
foreach (var item in plan)
|
||||
{
|
||||
if (item.Old.Id == id) next = item.Successor;
|
||||
}
|
||||
te += def.TractiveEffortKn; power += def.PowerKw; mass += def.MassT; vmax = Math.Min(vmax, def.MaxSpeedKmh);
|
||||
te2 += next.TractiveEffortKn; power2 += next.PowerKw; mass2 += next.MassT; vmax2 = Math.Min(vmax2, next.MaxSpeedKmh);
|
||||
}
|
||||
if (mass <= 0 || mass2 <= 0) return true;
|
||||
const double eps = 1e-9;
|
||||
return te2 + eps >= te && power2 + eps >= power && vmax2 + eps >= vmax && power2 / mass2 + eps >= power / mass;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Rinnovo in officina (intervento con effetto «renew»), all'avvio dei lavori: ogni veicolo del piano
|
||||
/// si vende al valore di rivendita (voce «vendita di treni») e al suo posto, nella stessa posizione
|
||||
/// della composizione, entra un veicolo nuovo del successore consigliato (voce «acquisto di treni»).
|
||||
/// I veicoli venduti restano nell'elenco con <c>Sold</c>, come quelli di <c>SellVehicle</c>.
|
||||
/// Il controllo della cassa spetta a chi chiama. Restituisce quanti veicoli sono stati sostituiti.
|
||||
/// </summary>
|
||||
public static int Renew(World w, Train t) => Renew(w, t, RenewalPlan(w, t));
|
||||
|
||||
/// <summary>Rinnovo con un piano già calcolato oggi (vedi <see cref="Renew(World, Train)"/>).</summary>
|
||||
public static int Renew(World w, Train t, List<RenewalItem> plan)
|
||||
{
|
||||
if (plan.Count == 0) return 0;
|
||||
var owner = Account.Of(t.Owner);
|
||||
foreach (var item in plan)
|
||||
|
||||
@@ -76,23 +76,27 @@ public sealed class VehicleModelInfo
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>Treno con veicoli superati da rinnovare: quanti, spesa netta (successori − rivendite + lavoro) e se la cassa basta.</summary>
|
||||
/// <summary>
|
||||
/// Treno con veicoli superati da rinnovare: quanti, spesa netta (successori − rivendite + lavoro), se la cassa
|
||||
/// basta al netto degli altri rinnovi prenotati e se il rinnovo è già prenotato (in viaggio o in coda all'officina).
|
||||
/// </summary>
|
||||
public sealed class RenewalTrainInfo
|
||||
{
|
||||
public int Train { get; init; }
|
||||
public int Vehicles { get; init; }
|
||||
public Money NetCost { get; init; }
|
||||
public bool Affordable { get; init; }
|
||||
public bool Booked { get; init; }
|
||||
|
||||
public void Write(ref SpanWriter w)
|
||||
{
|
||||
w.I32(Train); w.I32(Vehicles); w.Money(NetCost); w.Bool(Affordable);
|
||||
w.I32(Train); w.I32(Vehicles); w.Money(NetCost); w.Bool(Affordable); w.Bool(Booked);
|
||||
w.Flags(0);
|
||||
}
|
||||
|
||||
public static RenewalTrainInfo Read(ref SpanReader r)
|
||||
{
|
||||
var m = new RenewalTrainInfo { Train = r.I32(), Vehicles = r.I32(), NetCost = r.Money(), Affordable = r.Bool() };
|
||||
var m = new RenewalTrainInfo { Train = r.I32(), Vehicles = r.I32(), NetCost = r.Money(), Affordable = r.Bool(), Booked = r.Bool() };
|
||||
r.Flags();
|
||||
return m;
|
||||
}
|
||||
|
||||
@@ -647,7 +647,7 @@ public static class Projection
|
||||
{
|
||||
Type = m.Def.Id, Superseded = m.Superseded, SupersededYear = m.SupersededYear ?? 0, Successor = m.Successor?.Id ?? "", LastYear = m.LastYear ?? 0,
|
||||
}).ToList(),
|
||||
Trains = report.Trains.Select(t => new RenewalTrainInfo { Train = t.Train.Value, Vehicles = t.Vehicles, NetCost = t.NetCost, Affordable = t.Affordable }).ToList(),
|
||||
Trains = report.Trains.Select(t => new RenewalTrainInfo { Train = t.Train.Value, Vehicles = t.Vehicles, NetCost = t.NetCost, Affordable = t.Affordable, Booked = t.Booked }).ToList(),
|
||||
};
|
||||
}
|
||||
|
||||
|
||||
@@ -334,6 +334,157 @@ public static class ErasTests
|
||||
Assert.False(decoded.Models.Any(m => m.Type == "loco_diesel_1925"), "non ancora introdotto");
|
||||
}
|
||||
|
||||
private static void SetCash(World w, Company c, Money target)
|
||||
{
|
||||
var delta = target - c.Cash;
|
||||
if (delta.IsPositive) w.Money.Transfer(Account.External, Account.Of(c.Id), delta, LedgerEntry.Other);
|
||||
else if (delta.IsNegative) w.Money.Transfer(Account.Of(c.Id), Account.External, -delta, LedgerEntry.Other);
|
||||
}
|
||||
|
||||
[Test(Description = "Rinnovo: la cassa spesa tra prenotazione e avvio annulla il lavoro senza scoperto; due prenotazioni non impegnano la stessa cassa")]
|
||||
public static void RenewalCashIsCheckedAtStartAndCommitted()
|
||||
{
|
||||
var (f, depot) = ValdoriaIn(1878);
|
||||
var w = f.W;
|
||||
int a = f.Train(depot, "Primo", ("loco_steam_1850", 1), ("wagon_hopper", 1));
|
||||
int b = f.Train(depot, "Secondo", ("loco_steam_1850", 1), ("wagon_hopper", 1));
|
||||
var ta = w.Trains[a];
|
||||
var tb = w.Trains[b];
|
||||
// all'inizio di un giorno: l'officina avvia i lavori solo al giorno dopo
|
||||
w.RunTicks(w.Calendar.TicksPerDay - w.Clock.Tick % w.Calendar.TicksPerDay + 1);
|
||||
var cost = Obsolescence.RenewalCost(w, ta, Obsolescence.RenewalPlan(w, ta));
|
||||
Assert.True(cost.IsPositive, "il rinnovo costa");
|
||||
// cassa per un rinnovo solo: il secondo trova la cassa già impegnata dal primo
|
||||
SetCash(w, w.Player, cost + cost * 0.5);
|
||||
Assert.True(f.Do(new ScheduleServiceCommand(new TrainId(a), "renewal")).Ok);
|
||||
Assert.Equal(cost, Obsolescence.Committed(w, f.Me), "spesa impegnata dal rinnovo prenotato");
|
||||
var outlook = FleetOutlook.Build(w, f.Me);
|
||||
Assert.True(outlook.Trains.Single(x => x.Train.Value == a).Booked, "il primo è prenotato");
|
||||
var second = outlook.Trains.Single(x => x.Train.Value == b);
|
||||
Assert.False(second.Booked, "il secondo no");
|
||||
Assert.False(second.Affordable, "il secondo non è pagabile con la cassa già impegnata");
|
||||
var refused = f.Do(new ScheduleServiceCommand(new TrainId(b), "renewal"));
|
||||
Assert.Equal(CommandError.InsufficientFunds, refused.Error, refused.Message);
|
||||
Assert.True(refused.Message.Contains("impegnati", StringComparison.Ordinal), refused.Message);
|
||||
|
||||
// la cassa si spende altrove prima dell'avvio: il rinnovo si annulla, niente scoperto
|
||||
SetCash(w, w.Player, cost - new Money(1));
|
||||
var oldLoco = ta.Vehicles[0];
|
||||
w.Events.Drain();
|
||||
w.RunDays(2);
|
||||
Assert.False(ta.InWorkshop, "il treno esce dall'officina");
|
||||
Assert.Equal(-1, ta.PlannedIntervention);
|
||||
Assert.Equal(oldLoco, ta.Vehicles[0], "nessun veicolo sostituito");
|
||||
Assert.False(w.Vehicles[oldLoco.Value].Sold);
|
||||
Assert.False(w.Player.Cash.IsNegative, "la cassa non va in scoperto");
|
||||
Assert.Equal(0L, ta.MaintenanceThisYear, "nemmeno il lavoro è pagato");
|
||||
Assert.True(w.Events.Drain().Any(e => e.Severity == EventSeverity.Warning && e.Text.Contains("rinnovo annullato", StringComparison.Ordinal)),
|
||||
"notizia di avviso");
|
||||
Assert.Equal(Money.Zero, Obsolescence.Committed(w, f.Me), "niente più impegnato");
|
||||
|
||||
// con la cassa, il rinnovo si paga all'avvio e poi non impegna più nulla
|
||||
SetCash(w, w.Player, cost * 3);
|
||||
Assert.True(f.Do(new ScheduleServiceCommand(new TrainId(a), "renewal")).Ok);
|
||||
w.RunDays(2);
|
||||
Assert.True(ta.InWorkshop, "lavori in corso");
|
||||
Assert.Equal("loco_steam_1878", w.Vehicles[ta.Vehicles[0].Value].Def.Id, "veicoli sostituiti all'avvio");
|
||||
Assert.Equal(Money.Zero, Obsolescence.Committed(w, f.Me), "spesa già pagata");
|
||||
Assert.True(f.RunUntil(() => !ta.InWorkshop, 30), "rinnovo completato");
|
||||
Assert.True(tb.Vehicles.All(id => !w.Vehicles[id.Value].Sold));
|
||||
AssertInvariants(w, "dopo i rinnovi");
|
||||
}
|
||||
|
||||
[Test(Description = "Un rinnovo che all'avvio non ha più nulla da sostituire si annulla senza far pagare il lavoro")]
|
||||
public static void RenewalWithEmptyPlanAtStartIsCancelled()
|
||||
{
|
||||
// la Vittoria 2-8-0 si produce solo nel 1878: dal 1879 l'Ardita è superata ma senza successore in produzione
|
||||
var files = MemoryDataSource.Snapshot(TestData.Source);
|
||||
var vehicles = JsonNode.Parse(files["vehicles.json"])!;
|
||||
vehicles["vehicles"]!.AsArray().First(v => (string)v!["id"]! == "loco_steam_1878")!["eraTo"] = 1878;
|
||||
files["vehicles.json"] = vehicles.ToJsonString();
|
||||
var data = GameData.Load(new MemoryDataSource(files));
|
||||
var (f, depot) = ValdoriaIn(1878, data);
|
||||
var w = f.W;
|
||||
w.RunDays(w.Calendar.DaysPerYear - 3 - (int)w.Clock.Day);
|
||||
Assert.Equal(1878, w.Clock.Year);
|
||||
// due revisioni generali occupano gli stalli del deposito piccolo oltre la fine dell'anno
|
||||
for (int i = 0; i < w.Network.Depots[depot].Stalls; i++)
|
||||
{
|
||||
int busy = f.Train(depot, $"Occupato {i}", ("loco_steam_1878", 1));
|
||||
Assert.True(f.Do(new ScheduleServiceCommand(new TrainId(busy), "overhaul")).Ok);
|
||||
}
|
||||
int train = f.Train(depot, "Vecchio", ("loco_steam_1850", 1), ("wagon_hopper", 1));
|
||||
var t = w.Trains[train];
|
||||
Assert.Equal(1, Obsolescence.RenewalPlan(w, t).Count, "nel 1878 la Vittoria si compra");
|
||||
Assert.True(f.Do(new ScheduleServiceCommand(new TrainId(train), "renewal")).Ok);
|
||||
var oldLoco = t.Vehicles[0];
|
||||
w.Events.Drain();
|
||||
Assert.True(f.RunUntil(() => !t.InWorkshop, 120), "il rinnovo esce dalla coda");
|
||||
Assert.Equal(1879, w.Clock.Year);
|
||||
Assert.Equal(oldLoco, t.Vehicles[0], "nessun veicolo sostituito");
|
||||
Assert.Equal(0L, t.MaintenanceThisYear, "il lavoro non si paga");
|
||||
Assert.False(t.History.Any(h => h.Intervention == w.Data.Maintenance.InterventionIndex("renewal")), "nessun rinnovo nello storico");
|
||||
Assert.True(w.Events.Drain().Any(e => e.Severity == EventSeverity.Warning && e.Text.Contains("rinnovo annullato", StringComparison.Ordinal)),
|
||||
"notizia di avviso");
|
||||
Assert.Equal(0L, w.MoneyBalanceSum());
|
||||
}
|
||||
|
||||
[Test(Description = "La ricostruzione di un modello fuori produzione non lo rende nuovo nel patrimonio")]
|
||||
public static void RebuildKeepsBookAgeOfRetiredModels()
|
||||
{
|
||||
var (f, depot) = ValdoriaIn(1905);
|
||||
var w = f.W;
|
||||
int train = f.Train(depot, "Vecchio", ("loco_steam_1850", 1), ("wagon_hopper", 1));
|
||||
var t = w.Trains[train];
|
||||
w.RunDays(w.Calendar.DaysPerYear + 10);
|
||||
Assert.Equal(1906, w.Clock.Year);
|
||||
var loco = w.Vehicles[t.Vehicles[0].Value];
|
||||
var wagon = w.Vehicles[t.Vehicles[1].Value];
|
||||
long locoBought = loco.BoughtDay;
|
||||
long locoBook = Obsolescence.BookValueCents(w, loco);
|
||||
loco.Components[0] = 10;
|
||||
var replace = w.Data.Maintenance.Interventions[w.Data.Maintenance.InterventionIndex("repair_catastrophic")];
|
||||
Fleet.Apply(w, t, replace, Fleet.PolicyOf(w, t));
|
||||
Assert.Equal(locoBought, loco.BoughtDay, "l'Ardita non si produce più: età contabile invariata");
|
||||
Assert.Equal(locoBook, Obsolescence.BookValueCents(w, loco), "valore di libro invariato");
|
||||
Assert.True(loco.Components.All(c => c == 100), "componenti ricostruiti");
|
||||
Assert.Approx(1, Fleet.AgeFactor(w, loco), 1e-12, "l'usura riparte da capo");
|
||||
Assert.Equal(w.Clock.Day, wagon.BoughtDay, "il carro, ancora in produzione, torna nuovo");
|
||||
}
|
||||
|
||||
[Test(Description = "La Cronaca registra il contenuto di un anno con soli modelli fuori produzione")]
|
||||
public static void MilestoneOfRetirementOnlyYear()
|
||||
{
|
||||
var d = TestData.Data;
|
||||
Assert.Equal(0, EraSystem.Unlocks(d, 1906).Count, "nel 1906 nessuno sblocco");
|
||||
var (f, _) = ValdoriaIn(1878);
|
||||
EraSystem.Announce(f.W, 1906);
|
||||
string text = f.W.Player.Milestones[^1].Text;
|
||||
Assert.True(text.StartsWith("novità del 1906: ", StringComparison.Ordinal) && text.Contains("fuori produzione: Ardita 2-6-0", StringComparison.Ordinal), text);
|
||||
}
|
||||
|
||||
[Test(Description = "Scelte delle IA: carrozze non superate, rinnovi che non peggiorano trazione, potenza, velocità e potenza/massa")]
|
||||
public static void AiChoicesAvoidSupersededAndWeakerModels()
|
||||
{
|
||||
var (f1949, _) = ValdoriaIn(1878);
|
||||
Assert.Equal("coach_worker", Estimators.CoachFor(f1949.W, PaxClass.Worker, 1949)!.Id);
|
||||
Assert.Equal("coach_modern", Estimators.CoachFor(f1949.W, PaxClass.Worker, 1950)!.Id, "dal 1950 la carrozza operai è superata");
|
||||
Assert.Equal("coach_staff", Estimators.CoachFor(f1949.W, PaxClass.Staff, 1950)!.Id, "senza successore resta quella");
|
||||
|
||||
bool Keeps(int year, params (string Type, int Count)[] vehicles)
|
||||
{
|
||||
var (f, depot) = ValdoriaIn(year);
|
||||
var t = f.W.Trains[f.Train(depot, "Prova", vehicles)];
|
||||
var plan = Obsolescence.RenewalPlan(f.W, t);
|
||||
Assert.True(plan.Count > 0, $"{year}: qualcosa da rinnovare");
|
||||
return Obsolescence.KeepsPerformance(f.W, t, plan);
|
||||
}
|
||||
Assert.True(Keeps(1878, ("loco_steam_1850", 1), ("wagon_hopper", 3)), "Ardita → Vittoria migliora tutto");
|
||||
Assert.False(Keeps(1902, ("loco_steam_1878", 1), ("wagon_hopper", 3)), "Vittoria → Freccia perde sforzo di trazione");
|
||||
Assert.True(Keeps(1925, ("loco_steam_1878", 1), ("wagon_hopper", 3)), "dal 1925 la Vittoria passa all'Aquila D1");
|
||||
Assert.False(Keeps(1950, ("loco_diesel_1925", 1), ("coach_worker", 8)), "carrozze più pesanti con la stessa potenza");
|
||||
}
|
||||
|
||||
[Test(Slow = true, Description = "Le IA rinnovano i treni con locomotive superate, senza comandi rifiutati oltre il 5 %")]
|
||||
public static void AiRenewsSupersededTrains()
|
||||
{
|
||||
|
||||
@@ -202,7 +202,7 @@ public static class ProtocolTests
|
||||
],
|
||||
Models = [new VehicleModelInfo { Type = "loco_steam_1850", Superseded = true, SupersededYear = 1878, Successor = "loco_steam_1878", LastYear = 1905 },
|
||||
new VehicleModelInfo { Type = "wagon_hopper" }],
|
||||
Trains = [new RenewalTrainInfo { Train = 1, Vehicles = 1, NetCost = new Money(3_056_000), Affordable = true }],
|
||||
Trains = [new RenewalTrainInfo { Train = 1, Vehicles = 1, NetCost = new Money(3_056_000), Affordable = true, Booked = true }],
|
||||
};
|
||||
yield return new FinanceReport
|
||||
{
|
||||
|
||||
Reference in new issue
Block a user