From 596ce2c376e6ed9c22ce88c7f6b9e80f58616c31 Mon Sep 17 00:00:00 2001 From: Alberto Balbo Date: Sat, 7 Nov 2026 16:05:29 +0100 Subject: [PATCH] F6: compravendita in proprio, correzioni della revisione MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit La revisione ha trovato casi in cui la merce della compagnia, già pagata, poteva perdersi o restare bloccata, e il magazzino di destinazione restare prenotato per sempre. Le correzioni: - Il percorso della merce propria rispetta i flag carico e scarico delle fermate: LineGraph.From ha l'opzione stopFlags. ShipGoods rifiuta con Blocked la spedizione che esiste solo ignorando i flag. I pacchetti dei clienti non cambiano: l'accettazione F4 dà ancora 35/20 e 75/2. - La scadenza in stazione della merce propria riparte a ogni trasbordo. - La merce propria in attesa ricalcola ogni giorno il tratto sulle linee di quel giorno; se non c'è più un percorso torna nel magazzino. - La merce propria a bordo scende alla prima fermata quando il suo tratto non è più sulla linea del treno. Un treno che lascia la linea (riassegnato, al deposito, in riserva, fine copertura) la lascia alla stazione dove si trova o alla prossima fermata. - Una stazione con merce propria in partenza o in arrivo non si demolisce. - La merce propria, in magazzino e in viaggio, entra nel valore contabile al prezzo globale: un acquisto non abbassa più il patrimonio netto dell'intero importo. - Solo l'acquisto richiede lo sblocco del livello: la merce ereditata con una fusione si vende e si spedisce, e il riquadro del pannello compare. - Nel riquadro, la stazione di arrivo predefinita è diversa da quella di partenza. ADR 0016 e STATE aggiornati; sei test nuovi in TradingTests. Refs #31. Co-Authored-By: Claude Opus 5.5 --- .../assets/i18n/strings.csv | 1 + .../scripts/Panels/MarketPanel.cs | 9 +- .../scripts/Panels/TradeBox.cs | 39 ++++- docs/STATE.md | 5 +- docs/adr/0016-compravendita-in-proprio.md | 33 +++- src/RailEnterprise.Core/Rail/LineGraph.cs | 31 +++- .../Simulation/MaintenanceCommandHandlers.cs | 1 + .../Simulation/RailCommandHandlers.cs | 5 + .../Simulation/Systems/FinanceSystem.cs | 26 ++- .../Systems/FleetMaintenanceSystem.cs | 1 + .../Simulation/Systems/StationSystem.cs | 22 +++ .../Simulation/Systems/StationWork.cs | 71 +++++++- .../Simulation/TradingCommandHandlers.cs | 25 ++- .../Economy/TradingTests.cs | 156 +++++++++++++++++- 14 files changed, 389 insertions(+), 36 deletions(-) diff --git a/client/RailEnterprise.Client/assets/i18n/strings.csv b/client/RailEnterprise.Client/assets/i18n/strings.csv index 1b08d4b..8f8849a 100644 --- a/client/RailEnterprise.Client/assets/i18n/strings.csv +++ b/client/RailEnterprise.Client/assets/i18n/strings.csv @@ -537,3 +537,4 @@ unità,,units di cui,,of which Vuoto,,Empty Scegli una stazione di arrivo diversa da quella di partenza,,Choose a destination station different from the departure one +Hai merce nei magazzini: puoi venderla o spedirla, ma non comprarne altra.,,"You have goods in your warehouses: you can sell or ship them, but not buy more." diff --git a/client/RailEnterprise.Client/scripts/Panels/MarketPanel.cs b/client/RailEnterprise.Client/scripts/Panels/MarketPanel.cs index 199ea25..4fdd28a 100644 --- a/client/RailEnterprise.Client/scripts/Panels/MarketPanel.cs +++ b/client/RailEnterprise.Client/scripts/Panels/MarketPanel.cs @@ -131,7 +131,7 @@ public partial class MarketPanel : VBoxContainer if (_session.World.Market is { } report) { ShowGood(_session.World, report); - _trade.Update(report, good); + _trade.Update(report, good, report.TradingUnlocked); } } @@ -517,6 +517,13 @@ public partial class MarketPanel : VBoxContainer col.AddChild(Wrapped($"{T("Compra merci all'origine e rivendile dove il prezzo è più alto. Si sblocca al livello")} {tier}.", 13, Palette.Text)); col.AddChild(Bar(report.TradingProgress, Palette.Amber)); col.AddChild(UiTheme.Text($"{T("Avanzamento verso")} {tier}: {Fmt.Pct(report.TradingProgress, 0)}", 12, Palette.TextSecondary)); + // merce già in magazzino (per esempio ereditata da una fusione): si vende e si spedisce anche senza lo sblocco + if (report.Warehouses.Any(h => h.Incoming > 0 || h.Goods.Any(g => g.Units > 0))) + { + col.AddChild(Wrapped(T("Hai merce nei magazzini: puoi venderla o spedirla, ma non comprarne altra."), 13, Palette.Text)); + col.AddChild(_trade); + _trade.Update(report, _selected, buyAllowed: false); + } col.AddChild(Requirement($"{T("Patrimonio netto")} {report.NetWorth.ToString("short")} / {report.NetWorthRequired.ToString("short")}", report.NetWorth.Cents >= report.NetWorthRequired.Cents)); col.AddChild(Requirement($"{T("Città collegate oltre")} {Fmt.Number(report.TownPopulation, 0)} {T("abitanti")}: {report.TownsConnected} / {report.TownsRequired}", diff --git a/client/RailEnterprise.Client/scripts/Panels/TradeBox.cs b/client/RailEnterprise.Client/scripts/Panels/TradeBox.cs index 84bba9b..a9f42c0 100644 --- a/client/RailEnterprise.Client/scripts/Panels/TradeBox.cs +++ b/client/RailEnterprise.Client/scripts/Panels/TradeBox.cs @@ -37,6 +37,7 @@ public sealed partial class TradeBox : VBoxContainer private readonly List _destinationIds = []; private MarketReport? _report; private int _goodId = -1; + private bool _buyAllowed = true; /// Esito di un comando: il pannello chiede subito un quadro aggiornato. public event Action? Traded; @@ -51,7 +52,11 @@ public sealed partial class TradeBox : VBoxContainer station.AddChild(UiTheme.Text(T("Stazione"), 13, Palette.TextSecondary)); station.AddChild(_station); AddChild(station); - _station.ItemSelected += _ => Render(); + _station.ItemSelected += _ => + { + PickDestination(SelectedDestination); + Render(); + }; AddChild(_good); AddChild(_quote); @@ -84,14 +89,19 @@ public sealed partial class TradeBox : VBoxContainer AddChild(_status); } - /// Aggiorna stazioni, quotazioni e giacenze dal quadro ricevuto, per la merce scelta. - public void Update(MarketReport report, int good) + /// + /// Aggiorna stazioni, quotazioni e giacenze dal quadro ricevuto, per la merce scelta. Senza lo + /// sblocco del livello ( falso) si vende e si spedisce solo la merce + /// già in magazzino, per esempio quella ereditata da una fusione. + /// + public void Update(MarketReport report, int good, bool buyAllowed = true) { _report = report; _goodId = good; + _buyAllowed = buyAllowed; var w = _session.World; int keep = _station.Selected >= 0 && _station.Selected < _stationIds.Count ? _stationIds[_station.Selected] : -1; - int keepTo = _destination.Selected >= 0 && _destination.Selected < _destinationIds.Count ? _destinationIds[_destination.Selected] : -1; + int keepTo = SelectedDestination; _stationIds.Clear(); _station.Clear(); foreach (var h in report.Warehouses) @@ -108,11 +118,26 @@ public sealed partial class TradeBox : VBoxContainer _destinationIds.Add(h.Station); _destination.AddItem(StationName(w, h.Station)); } - int to = _destinationIds.IndexOf(keepTo); - if (_destinationIds.Count > 0) _destination.Select(to >= 0 ? to : Math.Min(1, _destinationIds.Count - 1)); + PickDestination(keepTo); Render(); } + private int SelectedDestination => + _destination.Selected >= 0 && _destination.Selected < _destinationIds.Count ? _destinationIds[_destination.Selected] : -1; + + /// + /// Mantiene la stazione di arrivo scelta se è ancora nell'elenco e diversa da quella di partenza, + /// altrimenti sceglie la prima diversa dalla partenza. + /// + private void PickDestination(int keep) + { + if (_destinationIds.Count == 0) return; + int from = _station.Selected >= 0 && _station.Selected < _stationIds.Count ? _stationIds[_station.Selected] : -1; + int to = _destinationIds.IndexOf(keep); + if (to < 0 || _destinationIds[to] == from) to = _destinationIds.FindIndex(id => id != from); + _destination.Select(to >= 0 ? to : 0); + } + private WarehouseInfo? Current => _report is null || _station.Selected < 0 || _station.Selected >= _stationIds.Count ? null @@ -144,7 +169,7 @@ public sealed partial class TradeBox : VBoxContainer ? $"{T("si vende a")} {Price(g.SellPrice)}/{unit} ({Fmt.Number(g.SellUnits, 0)} {unit} {T("richieste")})" : T("nessun consumatore né hub nel bacino la compra"); _quote.Text = $"{buy}; {sell}. {T("Prezzo locale: sale man mano che il venditore si svuota e scende man mano che il compratore si riempie.")}"; - _buy.Disabled = g is not { BuyPrice: >= 0 }; + _buy.Disabled = !_buyAllowed || g is not { BuyPrice: >= 0 }; _sell.Disabled = g is not { SellPrice: >= 0 } || g.Units <= 0; _ship.Disabled = (g?.Units ?? 0) <= 0 || _destinationIds.Count < 2; int used = house!.Goods.Sum(x => x.Units) + house.Incoming; diff --git a/docs/STATE.md b/docs/STATE.md index 0a17a80..c289a81 100644 --- a/docs/STATE.md +++ b/docs/STATE.md @@ -108,7 +108,8 @@ Aggiornato alla fine di ogni fase (guida, sezione 18). - salvataggio: corpo versione 4 (`TradingSerializer`), migrazione delle versioni 1–3 con i magazzini vuoti, magazzini e merce propria nell'hash; - protocollo: comando 40, blocco 1 di `MarketReport` con i magazzini e le quotazioni della prossima unità; client: riquadro «Compravendita in proprio» del Mercato globale (stazione, quantità, Compra, Vendi, Spedisci a, giacenze; tetto e minimo al 10 % dal prezzo mostrato), testi in `strings.csv`; - le IA non commerciano ancora (ADR 0016 §9); - - test (`Economy/TradingTests.cs`, 11): acquisto dal produttore e dall'hub, vendita al consumatore e all'hub, rifiuti senza effetti, spedizione senza tariffa, un anno di commercio con gli invarianti, determinismo e salvataggio con merce in magazzino e in viaggio, migrazione dalla versione 3, magazzini nel quadro del mercato, round-trip del comando 40. 137 test (124 senza i lenti). + - correzioni della revisione: la merce propria segue i flag carico/scarico delle fermate (`LineGraph` con `stopFlags`), la scadenza riparte al trasbordo, ricalcolo giornaliero del tratto in attesa, scarico della merce a bordo dei treni che lasciano la linea o il cui tratto non è più sulla linea, niente demolizione con merce propria in partenza o in arrivo, merce propria nel valore contabile al prezzo globale, vendita e spedizione senza lo sblocco del livello (solo l'acquisto lo richiede), stazione di arrivo predefinita diversa dalla partenza nel riquadro; + - test (`Economy/TradingTests.cs`, 17): acquisto dal produttore e dall'hub, vendita al consumatore e all'hub, rifiuti senza effetti, spedizione senza tariffa, un anno di commercio con gli invarianti, determinismo e salvataggio con merce in magazzino e in viaggio, migrazione dalla versione 3, magazzini nel quadro del mercato, round-trip del comando 40, flag delle fermate, treno tolto dalla linea, linea modificata con la merce a bordo, scadenza al trasbordo, demolizione bloccata, valore contabile. 143 test (126 senza i lenti). - Restano della F6: eventi, finanza completa, livelli e sblocchi nell'interfaccia, ere e obsolescenza, pannelli 07–08, tooltip «perché», tutorial, audio, bilanciamento con i bot. ## Prossimo passo @@ -121,7 +122,7 @@ Aggiornato alla fine di ogni fase (guida, sezione 18). - 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 client non è stato provato su Windows né esportato (servono i template di esportazione di Godot); la partita locale usa il server compilato dal repository o `RE_SERVER_PATH`. - Nella vista d'insieme i fiumi larghi una cella mostrano ancora gradini. Le immagini di riferimento 06–09 sono arrivate (novembre 2026): il Mercato globale è allineato alla 06 (F6, non ancora provato in Godot: qui manca l'editor); Industria, Scalata e la schermata di connessione vanno allineati in F6. -- Compravendita in proprio (ADR 0016): la quotazione nel pannello non considera la cassa delle industrie compratrici; una spedizione tiene occupato lo spazio di destinazione per tutto il viaggio; se una linea sparisce durante il viaggio la merce si ferma nel magazzino della stazione dove si trova anche oltre la capacità; la merce in attesa in stazione scade come le altre merci; il riquadro non è ancora stato provato in Godot (qui manca l'editor). +- Compravendita in proprio (ADR 0016): la quotazione nel pannello non considera la cassa delle industrie compratrici; una spedizione tiene occupato lo spazio di destinazione per tutto il viaggio; se una linea sparisce durante il viaggio la merce si ferma nel magazzino della stazione dove si trova anche oltre la capacità; un treno che lascia la linea in viaggio lascia la merce propria alla prossima fermata senza percorrere il tratto; la merce in attesa in stazione scade come le altre merci (la scadenza riparte a ogni trasbordo); il riquadro non è ancora stato provato in Godot (qui manca l'editor). - Mercato globale (ADR 0015): la previsione segue solo la componente mondiale (ciclo e shock), non domanda e offerta della mappa; «Dove conviene vendere» dà il prezzo alla destinazione, senza il costo del trasporto. - In F3 tutte le sessioni guidano la compagnia del giocatore (ADR 0009). - Il bilanciamento economico è provvisorio (F6): nello scenario l'acciaieria cresce di livello ogni due trimestri finché la linea operai non satura; il prezzo del minerale sale oltre 1,5 volte il base e il margine dei trasformatori diventa negativo quando la domanda supera l'offerta delle miniere. diff --git a/docs/adr/0016-compravendita-in-proprio.md b/docs/adr/0016-compravendita-in-proprio.md index d663325..ef9fa08 100644 --- a/docs/adr/0016-compravendita-in-proprio.md +++ b/docs/adr/0016-compravendita-in-proprio.md @@ -19,10 +19,16 @@ invarianti. tutti i beni insieme) in `balance.json`. Le unità di merce propria in viaggio verso una stazione (pacchetti propri in stazione e a bordo) occupano già il suo magazzino: lo spazio libero è capacità − giacenza − in arrivo. Il magazzino segue la stazione se cambia proprietario (fusioni, - aste); con la liquidazione la merce va persa (deperita). Una stazione con merce in magazzino non - si demolisce. Ogni mese la compagnia paga `trading.storageCostPerUnitPerMonth` (25 centesimi) per + aste); con la liquidazione la merce va persa (deperita). Una stazione con merce in magazzino, o + con merce propria in attesa di partire o in arrivo, non si demolisce. Ogni mese la compagnia paga `trading.storageCostPerUnitPerMonth` (25 centesimi) per unità in magazzino, sulla voce «Commercio». La merce in magazzino non deperisce. È contata da - `World.TotalStock` (invariante «merci») e nelle scorte del Mercato globale. + `World.TotalStock` (invariante «merci») e nelle scorte del Mercato globale. La merce propria, in + magazzino e in viaggio, entra nel valore contabile degli attivi (`AssetBookValue`, quindi nel + patrimonio netto per livelli, rating e borsa) al prezzo globale del mese: comprare costa al + patrimonio solo la differenza dal prezzo globale e la giacenza. + Lo sblocco del livello serve solo per comprare: la merce già in magazzino, per esempio quella + ereditata con una fusione da una controllata di livello più alto, si vende e si spedisce sempre, + e il riquadro del pannello compare anche senza lo sblocco quando c'è merce nei magazzini. 2. **Prezzo locale marginale.** Ogni unità si paga al prezzo locale (ADR 0004 §3) calcolato con la giacenza che il venditore o il compratore ha in quel momento, unità dopo unità. Per un produttore: Dl = spazio libero del magazzino dell'output (capienza − giacenza), Sl = giacenza: pieno vale @@ -53,7 +59,12 @@ invarianti. dal magazzino di `from` e crea un pacchetto merci con `Owned = true` diretto alla stazione `to` della compagnia, instradato sul grafo delle linee come gli altri (ADR 0008: carico per linea e bene, trasbordi, sosta proporzionale alle unità) e con la scadenza in stazione del bene - (`decayDaysAtStation`), come ogni merce in attesa. Senza tariffa (la merce è della compagnia) e + (`decayDaysAtStation`), come ogni merce in attesa; la scadenza riparte a ogni trasbordo, così + conta solo il tempo passato ad aspettare in una stazione e non quello del viaggio. A differenza dei + pacchetti dei clienti, il percorso della merce propria rispetta i flag delle fermate: si sale su + una linea solo dove una sua fermata carica e, ai cambi, si scende solo dove una fermata della linea + lasciata scarica (`LineGraph.From(…, stopFlags: true)`); se un percorso esiste solo ignorando i + flag il comando si rifiuta con `Blocked`. Senza tariffa (la merce è della compagnia) e senza consumatore: all'arrivo entra nel magazzino di `to`. Non tocca `Incoming` (che misura il bisogno dei consumatori nella scelta delle destinazioni), quindi la scelta delle destinazioni e i pacchetti esistenti non cambiano. Si rifiuta se non c'è un percorso per quel bene, se le stazioni @@ -62,10 +73,16 @@ invarianti. calcolato con la merce già in arrivo, e si rifiuta (`Blocked`) se è zero. Così all'arrivo la merce entra sempre nel magazzino, senza un secondo stato «in attesa del magazzino» con scadenze proprie; il prezzo è che una spedizione lunga tiene occupato lo spazio di destinazione per tutto il viaggio. - Se il percorso sparisce durante il viaggio (linea cancellata o modificata), al trasbordo la merce - entra nel magazzino della stazione dove si trova, anche oltre la capacità: comprare e ricevere - altre spedizioni lì resta bloccato finché non si vende o si rispedisce. Un deragliamento la perde - come il resto del carico. + Se il percorso sparisce durante il viaggio (linea cancellata o modificata), la merce entra nel + magazzino della stazione dove si trova, anche oltre la capacità: comprare e ricevere altre + spedizioni lì resta bloccato finché non si vende o si rispedisce. Per questo la merce propria in + attesa ricalcola il tratto ogni giorno sulle linee di quel giorno (senza percorso torna in + magazzino); quella a bordo scende alla prima stazione in cui il treno si ferma se il suo tratto + non è più sulla linea del treno (o la fine del tratto non scarica più) e da lì riparte o entra in + magazzino; un treno che lascia la linea (riassegnato, mandato al deposito, messo in riserva, fine + della copertura di una riserva) la lascia subito alla stazione dove si trova o, se è in viaggio, + alla prossima fermata della linea. Così la merce non resta mai a bordo senza un tratto e lo spazio + prenotato a destinazione si libera. Un deragliamento la perde come il resto del carico. 7. **Salvataggio, versione 4.** `TradingSerializer` aggiunge in coda allo stato dinamico i magazzini (beni per id testuale, solo quelli non vuoti) e gli id dei pacchetti propri in ogni stazione e treno: il formato dei pacchetti di `RailSerializer` non cambia. Entra nell'hash giornaliero. I diff --git a/src/RailEnterprise.Core/Rail/LineGraph.cs b/src/RailEnterprise.Core/Rail/LineGraph.cs index d456115..6efefc0 100644 --- a/src/RailEnterprise.Core/Rail/LineGraph.cs +++ b/src/RailEnterprise.Core/Rail/LineGraph.cs @@ -23,7 +23,11 @@ public sealed class LineGraph private readonly record struct Segment(int From, int To, LineId Line, double Minutes, ulong Carries); private readonly Dictionary> _out = new(); - private readonly Dictionary<(int, ulong), Dictionary> _reach = new(); + private readonly Dictionary<(int, ulong, bool), Dictionary> _reach = new(); + // per (linea, stazione): almeno una fermata carica (bit 1) o scarica (bit 2) + private readonly Dictionary<(int Line, int Station), byte> _stopFlags = new(); + private const byte LoadFlag = 1; + private const byte UnloadFlag = 2; private readonly double _transferMinutes; /// Bit del carico «lavoratori» (i bit bassi sono i beni, uno per indice). @@ -82,6 +86,14 @@ public sealed class LineGraph } } Carries[line.Id.Value] = carries; + foreach (var stop in line.Stops) + { + var key = (line.Id.Value, stop.Station.Value); + _stopFlags.TryGetValue(key, out byte flags); + if (stop.Load) flags |= LoadFlag; + if (stop.Unload) flags |= UnloadFlag; + _stopFlags[key] = flags; + } // sosta stimata a ogni fermata: scarico e carico completi del treno più capiente double dwell = sp.MinDwellMinutes; foreach (var t in trains) @@ -139,10 +151,13 @@ public sealed class LineGraph /// /// Collegamenti migliori da una stazione verso tutte le stazioni raggiungibili con linee i cui /// treni portano il carico indicato (maschera: beni, , ). + /// Con si sale su una linea solo dove una sua fermata carica e, ai + /// cambi, si scende solo dove una fermata della linea lasciata scarica (merce della compagnia, + /// ADR 0016); senza, il grafo ignora i flag delle fermate come per i pacchetti dei clienti. /// - public IReadOnlyDictionary From(StationId origin, ulong cargo) + public IReadOnlyDictionary From(StationId origin, ulong cargo, bool stopFlags = false) { - if (_reach.TryGetValue((origin.Value, cargo), out var cached)) return cached; + if (_reach.TryGetValue((origin.Value, cargo, stopFlags), out var cached)) return cached; var result = new Dictionary(); // stato = (stazione, linea su cui si viaggia); linea −1 = a terra all'origine var best = new Dictionary<(int, int), double>(); @@ -160,6 +175,12 @@ public sealed class LineGraph foreach (var seg in segs) { if ((seg.Carries & cargo) == 0) continue; + if (stopFlags && seg.Line.Value != state.Line) + { + // salita sulla linea del tratto e, se si cambia, discesa da quella su cui si viaggia + if (!HasFlag(seg.Line.Value, state.Station, LoadFlag)) continue; + if (state.Line >= 0 && !HasFlag(state.Line, state.Station, UnloadFlag)) 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; @@ -168,10 +189,12 @@ public sealed class LineGraph open.Enqueue(next, (c, seg.To, seg.Line.Value)); } } - _reach[(origin.Value, cargo)] = result; + _reach[(origin.Value, cargo, stopFlags)] = result; return result; } + private bool HasFlag(int line, int station, byte flag) => _stopFlags.TryGetValue((line, station), out byte f) && (f & flag) != 0; + private static Connection BuildConnection((int Station, int Line) state, double cost, Dictionary<(int, int), ((int, int) Prev, Segment Seg)> came, int origin) { diff --git a/src/RailEnterprise.Core/Simulation/MaintenanceCommandHandlers.cs b/src/RailEnterprise.Core/Simulation/MaintenanceCommandHandlers.cs index 74944bc..15262ff 100644 --- a/src/RailEnterprise.Core/Simulation/MaintenanceCommandHandlers.cs +++ b/src/RailEnterprise.Core/Simulation/MaintenanceCommandHandlers.cs @@ -24,6 +24,7 @@ public static class MaintenanceCommandHandlers train.Reserve = true; if (train.Line.IsValid) { + StationWork.DropOwnedCargo(w, train, train.Line); train.Line = LineId.None; w.LineGraphs.Touch(); } diff --git a/src/RailEnterprise.Core/Simulation/RailCommandHandlers.cs b/src/RailEnterprise.Core/Simulation/RailCommandHandlers.cs index 4d40ff2..d5c0606 100644 --- a/src/RailEnterprise.Core/Simulation/RailCommandHandlers.cs +++ b/src/RailEnterprise.Core/Simulation/RailCommandHandlers.cs @@ -256,6 +256,9 @@ public static class RailCommandHandlers if (st.PlatformTrain.Any(t => t >= 0)) return reply(CommandError.Blocked, "Ci sono treni in stazione"); if (w.Lines.Any(l => !l.Removed && l.Stops.Any(s => s.Station == st.Id))) return reply(CommandError.NotAllowed, "La stazione è fermata di una linea"); if (st.StockTotal > 0) return reply(CommandError.NotAllowed, "Il magazzino della stazione contiene merce: vendila o spediscila prima di demolire"); + // merce della compagnia spedita da qui e non ancora caricata, o in viaggio verso qui + if (st.Waiting.Any(p => p.Owned) || TradingMath.ReservedByStation(w)[st.Id.Value] > 0) + return reply(CommandError.NotAllowed, "C'è merce della compagnia in partenza o in arrivo in questa stazione: aspetta che arrivi o che torni in magazzino"); if (st.Waiting.Any(p => p.Kind == PacketKind.Freight)) { foreach (var p in st.Waiting.Where(p => p.Kind == PacketKind.Freight)) w.Goods.Decayed[p.Good] += p.Units; @@ -546,6 +549,7 @@ public static class RailCommandHandlers train.Covering = TrainId.None; } if (c.Line.IsValid) train.Reserve = false; + if (train.Line != c.Line) StationWork.DropOwnedCargo(w, train, train.Line); train.Line = c.Line; train.StopIndex = 0; if (!train.MaintenanceDepot.IsValid || train.GoingToDepot != train.MaintenanceDepot) train.GoingToDepot = DepotId.None; @@ -570,6 +574,7 @@ public static class RailCommandHandlers train.Covering = TrainId.None; } train.GoingToDepot = c.Depot; + StationWork.DropOwnedCargo(w, train, train.Line); train.Line = LineId.None; if (train.State == TrainState.NoRoute) train.State = TrainState.Waiting; w.LineGraphs.Touch(); diff --git a/src/RailEnterprise.Core/Simulation/Systems/FinanceSystem.cs b/src/RailEnterprise.Core/Simulation/Systems/FinanceSystem.cs index 1ccf0ba..5287ac2 100644 --- a/src/RailEnterprise.Core/Simulation/Systems/FinanceSystem.cs +++ b/src/RailEnterprise.Core/Simulation/Systems/FinanceSystem.cs @@ -83,7 +83,10 @@ public sealed class FinanceSystem : ISimSystem } } - /// Valore contabile degli attivi: binari e veicoli ammortizzati, stazioni e depositi al costo. + /// + /// Valore contabile degli attivi: binari e veicoli ammortizzati, stazioni e depositi al costo, + /// merce della compagnia (magazzini e spedizioni in viaggio) al prezzo globale (ADR 0016). + /// public static void UpdateBookValues(World w) { var fb = w.Data.Balance.Finance; @@ -110,9 +113,30 @@ public sealed class FinanceSystem : ISimSystem double age = (today - v.BoughtDay) / daysPerYear; values[v.Owner.Value] += (long)(v.Def.Price * Math.Max(fb.BookValueFloor, 1 - age / v.Def.LifeYears)); } + var prices = w.Market.GlobalPrice; + foreach (var s in w.Network.Stations) + { + if (!s.Owner.IsValid || s.Owner.Value >= values.Length) continue; + for (int g = 0; g < s.Stock.Length; g++) values[s.Owner.Value] += (long)(s.Stock[g] * prices[g]); + values[s.Owner.Value] += OwnedGoodsValue(s.Waiting, prices); + } + foreach (var t in w.Trains) + { + if (!t.Removed && t.Owner.IsValid && t.Owner.Value < values.Length) values[t.Owner.Value] += OwnedGoodsValue(t.Cargo, prices); + } for (int i = 0; i < w.Companies.Count; i++) w.Companies[i].AssetBookValue = new Money(values[i]); } + private static long OwnedGoodsValue(List packets, double[] prices) + { + long value = 0; + foreach (var p in packets) + { + if (p.Owned && p.Kind == Rail.PacketKind.Freight) value += (long)(p.Units * prices[p.Good]); + } + return value; + } + /// Rata mensile costante (alla francese) per il residuo e i mesi restanti. public static Money MonthlyPayment(Money remaining, double annualRate, int monthsLeft) { diff --git a/src/RailEnterprise.Core/Simulation/Systems/FleetMaintenanceSystem.cs b/src/RailEnterprise.Core/Simulation/Systems/FleetMaintenanceSystem.cs index 1f9ef46..bd8458e 100644 --- a/src/RailEnterprise.Core/Simulation/Systems/FleetMaintenanceSystem.cs +++ b/src/RailEnterprise.Core/Simulation/Systems/FleetMaintenanceSystem.cs @@ -585,6 +585,7 @@ public sealed class FleetMaintenanceSystem : ISimSystem t.CoveredBy = TrainId.None; if (r.Covering != t.Id) return; r.Covering = TrainId.None; + StationWork.DropOwnedCargo(w, r, r.Line); r.Line = LineId.None; if (r.HomeDepot.IsValid && w.Network.IsAlive(w.Network.Depots[r.HomeDepot.Value]) && w.Network.Depots[r.HomeDepot.Value].Node != r.AtNode) r.GoingToDepot = r.HomeDepot; diff --git a/src/RailEnterprise.Core/Simulation/Systems/StationSystem.cs b/src/RailEnterprise.Core/Simulation/Systems/StationSystem.cs index 1e00151..6dedef7 100644 --- a/src/RailEnterprise.Core/Simulation/Systems/StationSystem.cs +++ b/src/RailEnterprise.Core/Simulation/Systems/StationSystem.cs @@ -32,6 +32,7 @@ public sealed class StationSystem : ISimSystem foreach (var s in net.Stations) { if (net.Nodes[s.Node.Value].Station != s.Id) continue; + RerouteOwned(w, s); Expire(ctx, s); RetryDeliveries(w, s); } @@ -92,6 +93,27 @@ public sealed class StationSystem : ISimSystem return false; } + /// + /// Merce della compagnia in attesa (ADR 0016): ogni giorno ricalcola il tratto sulle linee di oggi, + /// così una linea modificata non la lascia ad aspettare un treno che non passa più; senza + /// percorso entra nel magazzino della stazione. + /// + private static void RerouteOwned(World w, Station s) + { + for (int i = s.Waiting.Count - 1; i >= 0; i--) + { + var p = s.Waiting[i]; + if (!p.Owned) continue; + if (StationWork.Route(w, s, ref p)) + { + s.Waiting[i] = p; + continue; + } + s.Waiting.RemoveAt(i); + TradingCommandHandlers.Store(w, s, p); + } + } + private static void Expire(WorldContext ctx, Station s) { var w = ctx.World; diff --git a/src/RailEnterprise.Core/Simulation/Systems/StationWork.cs b/src/RailEnterprise.Core/Simulation/Systems/StationWork.cs index 08f3d6b..32eb2a5 100644 --- a/src/RailEnterprise.Core/Simulation/Systems/StationWork.cs +++ b/src/RailEnterprise.Core/Simulation/Systems/StationWork.cs @@ -104,17 +104,74 @@ public static class StationWork { var p = t.Cargo[i]; bool final = p.Destination == s.Id; + if (p.Owned && !final && !StillOnHop(w, t, p)) + { + // merce della compagnia il cui tratto non è più su questa linea (linea modificata o + // treno riassegnato): scende qui e riparte da questa stazione o entra nel suo magazzino + t.Cargo.RemoveAt(i); + RemoveFromVehicles(w, t, p); + moved += p.Units; + Transfer(w, ctx.Tick, s, p); + continue; + } if (p.HopEnd != s.Id && !final) continue; if (!final && !unloadOrders) continue; t.Cargo.RemoveAt(i); RemoveFromVehicles(w, t, p); moved += p.Units; if (final) Deliver(ctx, t, s, p); - else Transfer(ctx, s, p); + else Transfer(w, ctx.Tick, s, p); } return moved; } + /// + /// Il pacchetto a bordo viaggia ancora sul suo tratto: il treno serve la linea del tratto e + /// una fermata della linea alla fine del tratto lo scarica (o è la destinazione). + /// + private static bool StillOnHop(World w, Train t, Packet p) + { + if (!t.Line.IsValid || t.Line != p.HopLine) return false; + var line = w.Lines[t.Line.Value]; + if (line.Removed) return false; + foreach (var stop in line.Stops) + { + if (stop.Station == p.HopEnd && (stop.Unload || p.HopEnd == p.Destination)) return true; + } + return false; + } + + /// + /// Il treno lascia la linea (riassegnato, mandato al deposito, messo in + /// riserva): la merce della compagnia a bordo scende alla stazione dove si trova il treno o alla + /// prossima fermata della linea, e da lì riparte o entra nel magazzino (ADR 0016). Senza nessuna + /// stazione della compagnia a disposizione la merce va persa. + /// + public static void DropOwnedCargo(World w, Train t, LineId line) + { + if (!t.Cargo.Any(p => p.Owned)) return; + var net = w.Network; + Station? here = null; + if (t.AtNode.IsValid && net.Nodes[t.AtNode.Value].Station is { IsValid: true } sid) here = net.Stations[sid.Value]; + else if (line.IsValid && line.Value < w.Lines.Count && w.Lines[line.Value] is { Removed: false, Stops.Count: > 0 } l) + here = net.Stations[l.Stops[t.StopIndex % l.Stops.Count].Station.Value]; + for (int i = t.Cargo.Count - 1; i >= 0; i--) + { + var p = t.Cargo[i]; + if (!p.Owned) continue; + t.Cargo.RemoveAt(i); + RemoveFromVehicles(w, t, p); + var s = here; + if (s is null || !net.IsAlive(s) || s.Owner != t.Owner) s = p.Origin.IsValid ? net.Stations[p.Origin.Value] : null; + if (s is null || !net.IsAlive(s) || s.Owner != t.Owner) + { + if (p.Kind == PacketKind.Freight) w.Goods.Decayed[p.Good] += p.Units; + continue; + } + Transfer(w, w.Context.Tick, s, p); + } + } + private static void Deliver(WorldContext ctx, Train t, Station s, Packet p) { var w = ctx.World; @@ -172,11 +229,12 @@ public static class StationWork if (Route(w, s, ref back)) s.Waiting.Add(back); } - private static void Transfer(WorldContext ctx, Station s, Packet p) + private static void Transfer(World w, long tick, Station s, Packet p) { - var w = ctx.World; if (Route(w, s, ref p)) { + // merce della compagnia: la scadenza in stazione riparte a ogni trasbordo (ADR 0016) + if (p.Owned) p.ExpiresTick = tick + (long)w.Data.Goods[p.Good].DecayDaysAtStation * w.Calendar.TicksPerDay; s.Waiting.Add(p); return; } @@ -195,11 +253,14 @@ public static class StationWork } } - /// Assegna al pacchetto il prossimo tratto verso la destinazione; false se irraggiungibile. + /// + /// Assegna al pacchetto il prossimo tratto verso la destinazione; false se irraggiungibile. La + /// merce della compagnia segue solo i percorsi dove le fermate la caricano e la scaricano ai cambi. + /// public static bool Route(World w, Station from, ref Packet p) { var graph = w.LineGraphs.For(w, from.Owner); - if (!graph.From(from.Id, LineGraph.CargoOf(p)).TryGetValue(p.Destination.Value, out var conn)) return false; + if (!graph.From(from.Id, LineGraph.CargoOf(p), p.Owned).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); diff --git a/src/RailEnterprise.Core/Simulation/TradingCommandHandlers.cs b/src/RailEnterprise.Core/Simulation/TradingCommandHandlers.cs index e4a4c3f..57fdbe8 100644 --- a/src/RailEnterprise.Core/Simulation/TradingCommandHandlers.cs +++ b/src/RailEnterprise.Core/Simulation/TradingCommandHandlers.cs @@ -16,7 +16,7 @@ public static class TradingCommandHandlers { public static CommandResult Buy(World w, Company company, BuyGoodsCommand c, RailCommandHandlers.Reply reply) { - if (!Check(w, company, c.Station, c.Good, c.Units, out var s, out int good, out var error)) return reply(error.Error, error.Message); + if (!Check(w, company, c.Station, c.Good, c.Units, true, out var s, out int good, out var error)) return reply(error.Error, error.Message); if (!MarketOutlook.IsAvailable(w, good)) return reply(CommandError.EraLocked, $"{GoodName(w, good)} non è ancora disponibile (dal {w.Data.Goods[good].Era})"); int free = TradingMath.FreeSpace(w, s, TradingMath.ReservedByStation(w)[s.Id.Value]); @@ -93,7 +93,7 @@ public static class TradingCommandHandlers public static CommandResult Sell(World w, Company company, SellGoodsCommand c, RailCommandHandlers.Reply reply) { - if (!Check(w, company, c.Station, c.Good, c.Units, out var s, out int good, out var error)) return reply(error.Error, error.Message); + if (!Check(w, company, c.Station, c.Good, c.Units, false, out var s, out int good, out var error)) return reply(error.Error, error.Message); int stock = s.StockOf(good); if (stock <= 0) return reply(CommandError.NotFound, $"Nel magazzino di {s.Name} non c'è {GoodName(w, good)}"); var buyers = TradingMath.Buyers(w, s, good); @@ -154,14 +154,21 @@ public static class TradingCommandHandlers public static CommandResult Ship(World w, Company company, ShipGoodsCommand c, WorldContext ctx, RailCommandHandlers.Reply reply) { - if (!Check(w, company, c.From, c.Good, c.Units, out var from, out int good, out var error)) return reply(error.Error, error.Message); + if (!Check(w, company, c.From, c.Good, c.Units, false, out var from, out int good, out var error)) return reply(error.Error, error.Message); if (!TryOwnStation(w, company, c.To, out var to, out error)) return reply(error.Error, error.Message); if (to.Id == from.Id) return reply(CommandError.InvalidArgument, "La stazione di partenza e quella di arrivo coincidono"); int stock = from.StockOf(good); if (stock <= 0) return reply(CommandError.NotFound, $"Nel magazzino di {from.Name} non c'è {GoodName(w, good)}"); + // percorso con i flag delle fermate: si carica alla partenza e si scarica a ogni cambio var graph = w.LineGraphs.For(w, company.Id); - if (!graph.From(from.Id, LineGraph.GoodCargo(good)).TryGetValue(to.Id.Value, out var conn)) - return reply(CommandError.NotFound, $"Nessuna linea della compagnia porta {GoodName(w, good)} da {from.Name} a {to.Name}"); + var cargo = LineGraph.GoodCargo(good); + if (!graph.From(from.Id, cargo, stopFlags: true).TryGetValue(to.Id.Value, out var conn)) + { + return graph.From(from.Id, cargo).ContainsKey(to.Id.Value) + ? reply(CommandError.Blocked, + $"Le linee da {from.Name} a {to.Name} non caricano la merce a {from.Name} o non la scaricano ai cambi: controlla carico e scarico delle fermate") + : reply(CommandError.NotFound, $"Nessuna linea della compagnia porta {GoodName(w, good)} da {from.Name} a {to.Name}"); + } int free = TradingMath.FreeSpace(w, to, TradingMath.ReservedByStation(w)[to.Id.Value]); if (free <= 0) return reply(CommandError.Blocked, $"Magazzino di {to.Name} pieno ({w.Data.Balance.Trading.WarehouseCapacity} unità comprese le spedizioni in arrivo)"); @@ -212,12 +219,16 @@ public static class TradingCommandHandlers // ------------------------------------------------------------------ validazione - private static bool Check(World w, Company company, StationId station, string goodId, int units, out Station s, out int good, + /// + /// Validazione comune. Lo sblocco del livello serve solo per comprare (): + /// la merce già in magazzino, per esempio ereditata con una fusione, si vende e si spedisce sempre. + /// + private static bool Check(World w, Company company, StationId station, string goodId, int units, bool needsUnlock, out Station s, out int good, out (CommandError Error, string Message) error) { good = -1; s = null!; - if (!Tiers.Unlocks(w, company).Trading) + if (needsUnlock && !Tiers.Unlocks(w, company).Trading) { var tier = w.Data.Tiers.Tiers.FirstOrDefault(t => t.Unlocks.Trading); error = (CommandError.TierLocked, tier is null diff --git a/tests/RailEnterprise.Tests/Economy/TradingTests.cs b/tests/RailEnterprise.Tests/Economy/TradingTests.cs index 37b0b0e..ad9d172 100644 --- a/tests/RailEnterprise.Tests/Economy/TradingTests.cs +++ b/tests/RailEnterprise.Tests/Economy/TradingTests.cs @@ -202,7 +202,12 @@ public static class TradingTests var locked = f.Do(new BuyGoodsCommand(port.Id, "coal", 10, Money.FromLire(1000))); Assert.Equal(CommandError.TierLocked, locked.Error); Assert.True(locked.Message.Contains("Compagnia regionale", StringComparison.Ordinal), locked.Message); - Assert.Equal(CommandError.TierLocked, f.Do(new ShipGoodsCommand(port.Id, mill.Id, "coal", 1)).Error); + // senza lo sblocco la merce già in magazzino (per esempio ereditata da una fusione) si vende e si spedisce + Assert.Equal(CommandError.NotFound, f.Do(new ShipGoodsCommand(port.Id, mill.Id, "coal", 1)).Error, "magazzino vuoto, non livello"); + Inject(w, port, coal, 5); + var inherited = f.Do(new SellGoodsCommand(port.Id, "coal", 5, Money.FromLire(1))); + Assert.True(inherited.Ok, inherited.Message); + Assert.Equal(0, port.StockOf(coal)); Unlock(w); Assert.Equal(CommandError.NotFound, f.Do(new BuyGoodsCommand(port.Id, "unobtainium", 10, Money.FromLire(1000))).Error); @@ -242,6 +247,55 @@ public static class TradingTests AssertInvariants(w, "dopo i rifiuti"); } + [Test(Description = "Una stazione con merce della compagnia in attesa di partire o in arrivo non si demolisce")] + public static void StationsWithOwnedGoodsInTransitAreNotDemolished() + { + var (f, mine, _, port) = Stations(); + var w = f.W; + int coal = GoodIndex(w, "coal"); + port.Waiting.Add(new Packet + { + Id = w.NextIds.Packet++, Kind = PacketKind.Freight, Good = coal, Units = 30, Origin = port.Id, Destination = mine.Id, + HopLine = LineId.None, HopEnd = mine.Id, CreatedTick = w.Context.Tick, ExpiresTick = w.Context.Tick + w.Calendar.TicksPerDay * 30, + Contract = -1, Owned = true, + }); + w.Goods.Produced[coal] += 30; + var leaving = f.Do(new DemolishCommand(DemolishTarget.Station, port.Id.Value)); + Assert.Equal(CommandError.NotAllowed, leaving.Error, leaving.Message); + var arriving = f.Do(new DemolishCommand(DemolishTarget.Station, mine.Id.Value)); + Assert.Equal(CommandError.NotAllowed, arriving.Error, arriving.Message); + Assert.True(w.Network.IsAlive(port) && w.Network.IsAlive(mine)); + Assert.Equal(30, port.Waiting.Single(p => p.Owned).Units); + + // senza linee il giorno dopo la merce torna nel magazzino della stazione, che resta da svuotare + w.RunDays(1); + Assert.False(port.Waiting.Any(p => p.Owned), "nessun pacchetto proprio in attesa"); + Assert.Equal(30, port.StockOf(coal)); + Assert.Equal(0, TradingMath.ReservedByStation(w)[mine.Id.Value]); + AssertInvariants(w, "dopo il rientro in magazzino"); + } + + [Test(Description = "La merce in magazzino e in viaggio entra nel valore contabile al prezzo globale")] + public static void OwnedGoodsCountInTheBookValue() + { + var (f, mine, _, port) = Stations(); + var w = f.W; + int coal = GoodIndex(w, "coal"); + int ore = GoodIndex(w, "iron_ore"); + FinanceSystem.UpdateBookValues(w); + var before = w.Player.AssetBookValue; + Inject(w, port, coal, 100); + mine.Waiting.Add(new Packet + { + Id = w.NextIds.Packet++, Kind = PacketKind.Freight, Good = ore, Units = 40, Origin = mine.Id, Destination = port.Id, + HopLine = LineId.None, HopEnd = port.Id, CreatedTick = 0, ExpiresTick = long.MaxValue, Contract = -1, Owned = true, + }); + w.Goods.Produced[ore] += 40; + FinanceSystem.UpdateBookValues(w); + long expected = (long)(100 * w.Market.GlobalPrice[coal]) + (long)(40 * w.Market.GlobalPrice[ore]); + Assert.Equal(expected, (w.Player.AssetBookValue - before).Cents); + } + /// /// Rete merci di Valdoria con un treno di carri coperti tra le miniere e l'acciaieria: la linea non /// porta minerale né acciaio, quindi le uniche merci a bordo sono quelle spedite dalla compagnia. @@ -307,6 +361,106 @@ public static class TradingTests Assert.Equal(CommandError.Blocked, f.Do(new ShipGoodsCommand(mine.Id, mill.Id, "goods", 10)).Error); } + [Test(Slow = true, Description = "Non si spedisce dove la fermata di partenza non carica; una linea modificata riporta in magazzino la merce in attesa")] + public static void ShippingFollowsTheLoadAndUnloadFlagsOfTheStops() + { + var (f, mine, mill, train) = BoxLine(); + var w = f.W; + int goods = GoodIndex(w, "goods"); + var line = train.Line; + Inject(w, mine, goods, 60); + f.Ok(new EditLineCommand(line, new[] { new LineStop(mine.Id, Load: false), new LineStop(mill.Id) })); + var refused = f.Do(new ShipGoodsCommand(mine.Id, mill.Id, "goods", 60)); + Assert.Equal(CommandError.Blocked, refused.Error, refused.Message); + Assert.Equal(60, mine.StockOf(goods)); + Assert.False(mine.Waiting.Any(p => p.Owned), "nessun pacchetto creato"); + + // spedita con la fermata che carica, poi la linea smette di caricare lì prima che passi il treno + f.Ok(new EditLineCommand(line, new[] { new LineStop(mine.Id), new LineStop(mill.Id) })); + Assert.True(f.Do(new ShipGoodsCommand(mine.Id, mill.Id, "goods", 60)).Ok); + Assert.Equal(0, mine.StockOf(goods)); + f.Ok(new EditLineCommand(line, new[] { new LineStop(mine.Id, Load: false), new LineStop(mill.Id) })); + w.RunDays(1); + Assert.False(mine.Waiting.Any(p => p.Owned) || train.Cargo.Any(p => p.Owned), "il pacchetto non aspetta più un treno che non lo carica"); + Assert.Equal(60, mine.StockOf(goods)); + Assert.Equal(0, TradingMath.ReservedByStation(w)[mill.Id.Value]); + AssertInvariants(w, "dopo il rientro in magazzino"); + } + + [Test(Slow = true, Description = "Un treno che lascia la linea con merce propria a bordo la lascia in un magazzino e libera lo spazio prenotato")] + public static void OwnedCargoLeavesATrainTakenOffItsLine() + { + var (f, mine, mill, train) = BoxLine(); + var w = f.W; + int goods = GoodIndex(w, "goods"); + Inject(w, mine, goods, 50); + Assert.True(f.Do(new ShipGoodsCommand(mine.Id, mill.Id, "goods", 50)).Ok); + Assert.True(f.RunUntil(() => train.Cargo.Any(p => p.Owned) && !train.AtNode.IsValid, 60), "la merce è a bordo e il treno in viaggio"); + Assert.Equal(50, TradingMath.ReservedByStation(w)[mill.Id.Value]); + + f.Ok(new AssignTrainCommand(train.Id, LineId.None)); + Assert.False(train.Cargo.Any(p => p.Owned), "nessun pacchetto proprio a bordo"); + Assert.True(train.Vehicles.All(v => w.Vehicles[v.Value].Load == 0), "carri vuoti"); + // in viaggio verso l'acciaieria, che è la destinazione: la merce entra nel suo magazzino + Assert.Equal(50, mill.StockOf(goods)); + Assert.Equal(0, TradingMath.ReservedByStation(w)[mill.Id.Value]); + AssertInvariants(w, "dopo il ritiro del treno"); + } + + [Test(Slow = true, Description = "Una linea modificata con la merce propria a bordo: scende alla prima fermata e torna in magazzino")] + public static void OwnedCargoOffTheEditedLineIsUnloaded() + { + var (f, mine, mill, train) = BoxLine(); + var w = f.W; + int goods = GoodIndex(w, "goods"); + Inject(w, mine, goods, 50); + Assert.True(f.Do(new ShipGoodsCommand(mine.Id, mill.Id, "goods", 50)).Ok); + Assert.True(f.RunUntil(() => train.Cargo.Any(p => p.Owned) && !train.AtNode.IsValid, 60), "la merce è a bordo e il treno in viaggio"); + + // la linea non arriva più all'acciaieria: il treno torna alle miniere + f.Ok(new EditLineCommand(train.Line, new[] { new LineStop(mine.Id), new LineStop(mine.Id) })); + Assert.True(f.RunUntil(() => !train.Cargo.Any(p => p.Owned), 60), "la merce scende dal treno"); + Assert.Equal(50, mine.StockOf(goods)); + Assert.Equal(0, mill.StockOf(goods)); + Assert.Equal(0, TradingMath.ReservedByStation(w)[mill.Id.Value]); + AssertInvariants(w, "dopo lo scarico"); + } + + [Test(Slow = true, Description = "Al trasbordo la scadenza in stazione della merce propria riparte da zero")] + public static void OwnedGoodsExpiryRestartsAtTransfer() + { + var (f, mine, mill, train) = BoxLine(); + var w = f.W; + int goods = GoodIndex(w, "goods"); + Assert.Equal(0, train.StopIndex); + // merce propria a bordo che scende alle miniere per proseguire verso l'acciaieria, con la scadenza già passata + int id = w.NextIds.Packet++; + train.Cargo.Add(new Packet + { + Id = id, Kind = PacketKind.Freight, Good = goods, Units = 20, Origin = mill.Id, Destination = mill.Id, + HopLine = train.Line, HopEnd = mine.Id, CreatedTick = 0, ExpiresTick = 0, Contract = -1, Owned = true, + }); + var wagon = w.Vehicles[train.Vehicles.First(v => w.Vehicles[v.Value].Def.Kind == RailEnterprise.Core.Data.VehicleKind.Wagon).Value]; + wagon.Good = goods; + wagon.Load = 20; + w.Goods.Produced[goods] += 20; + long decay = (long)w.Data.Goods[goods].DecayDaysAtStation * w.Calendar.TicksPerDay; + + Packet? after = null; + Assert.True(f.RunUntil(() => + { + foreach (var p in mine.Waiting.Concat(train.Cargo)) + if (p.Id == id && p.ExpiresTick != 0) after = p; + return after is not null || mill.StockOf(goods) > 0; + }, 60), "il pacchetto passa dalle miniere"); + Assert.True(after is { } a && a.ExpiresTick > w.Context.Tick - w.Calendar.TicksPerDay && a.ExpiresTick <= w.Context.Tick + decay, + $"scadenza rinnovata al trasbordo: {after?.ExpiresTick} al tick {w.Context.Tick}"); + long decayed = w.Goods.Decayed[goods]; + Assert.True(f.RunUntil(() => mill.StockOf(goods) == 20, 120), "la merce arriva all'acciaieria"); + Assert.Equal(decayed, w.Goods.Decayed[goods], "niente merce deperita"); + AssertInvariants(w, "all'arrivo"); + } + /// /// Un anno di commercio sulla rete merci di Valdoria (treno a tramogge): ogni mese si compra /// minerale dalla miniera, lo si spedisce all'acciaieria e si vende quello arrivato; restituisce il mondo.