F6: compravendita in proprio, correzioni della revisione
CI / Build e test (pull_request) Successful in 1m19s
CI / Immagine Docker (pull_request) Successful in 29s

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 <noreply@anthropic.com>
This commit is contained in:
Alby96andClaude Opus 5.5 committed 2026-11-07 16:05:29 +01:00
1 parent e157dd77bc
commit 596ce2c376
14 files changed
+389 -36

No files matched your search

@@ -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."
1 keys it en
537 di cui of which
538 Vuoto Empty
539 Scegli una stazione di arrivo diversa da quella di partenza Choose a destination station different from the departure one
540 Hai merce nei magazzini: puoi venderla o spedirla ma non comprarne altra.
@@ -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}",
@@ -37,6 +37,7 @@ public sealed partial class TradeBox : VBoxContainer
private readonly List<int> _destinationIds = [];
private MarketReport? _report;
private int _goodId = -1;
private bool _buyAllowed = true;
/// <summary>Esito di un comando: il pannello chiede subito un quadro aggiornato.</summary>
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);
}
/// <summary>Aggiorna stazioni, quotazioni e giacenze dal quadro ricevuto, per la merce scelta.</summary>
public void Update(MarketReport report, int good)
/// <summary>
/// Aggiorna stazioni, quotazioni e giacenze dal quadro ricevuto, per la merce scelta. Senza lo
/// sblocco del livello (<paramref name="buyAllowed"/> falso) si vende e si spedisce solo la merce
/// già in magazzino, per esempio quella ereditata da una fusione.
/// </summary>
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;
/// <summary>
/// Mantiene la stazione di arrivo scelta se è ancora nell'elenco e diversa da quella di partenza,
/// altrimenti sceglie la prima diversa dalla partenza.
/// </summary>
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;
+3 -2
View File
@@ -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.
+25 -8
View File
@@ -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
+27 -4
View File
@@ -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<int, List<Segment>> _out = new();
private readonly Dictionary<(int, ulong), Dictionary<int, Connection>> _reach = new();
private readonly Dictionary<(int, ulong, bool), Dictionary<int, Connection>> _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;
/// <summary>Bit del carico «lavoratori» (i bit bassi sono i beni, uno per indice).</summary>
@@ -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
/// <summary>
/// Collegamenti migliori da una stazione verso tutte le stazioni raggiungibili con linee i cui
/// treni portano il carico indicato (maschera: beni, <see cref="WorkersCargo"/>, <see cref="StaffCargo"/>).
/// Con <paramref name="stopFlags"/> 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.
/// </summary>
public IReadOnlyDictionary<int, Connection> From(StationId origin, ulong cargo)
public IReadOnlyDictionary<int, Connection> 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<int, Connection>();
// 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)
{
@@ -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();
}
@@ -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();
@@ -83,7 +83,10 @@ public sealed class FinanceSystem : ISimSystem
}
}
/// <summary>Valore contabile degli attivi: binari e veicoli ammortizzati, stazioni e depositi al costo.</summary>
/// <summary>
/// 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).
/// </summary>
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<Rail.Packet> 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;
}
/// <summary>Rata mensile costante (alla francese) per il residuo e i mesi restanti.</summary>
public static Money MonthlyPayment(Money remaining, double annualRate, int monthsLeft)
{
@@ -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;
@@ -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;
}
/// <summary>
/// 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.
/// </summary>
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;
@@ -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;
}
/// <summary>
/// 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).
/// </summary>
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;
}
/// <summary>
/// Il treno lascia la linea <paramref name="line"/> (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.
/// </summary>
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
}
}
/// <summary>Assegna al pacchetto il prossimo tratto verso la destinazione; false se irraggiungibile.</summary>
/// <summary>
/// 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.
/// </summary>
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);
@@ -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,
/// <summary>
/// Validazione comune. Lo sblocco del livello serve solo per comprare (<paramref name="needsUnlock"/>):
/// la merce già in magazzino, per esempio ereditata con una fusione, si vende e si spedisce sempre.
/// </summary>
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
@@ -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);
}
/// <summary>
/// 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");
}
/// <summary>
/// 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.