diff --git a/client/RailEnterprise.Client/assets/i18n/strings.csv b/client/RailEnterprise.Client/assets/i18n/strings.csv
index 5b17476..dd4319d 100644
--- a/client/RailEnterprise.Client/assets/i18n/strings.csv
+++ b/client/RailEnterprise.Client/assets/i18n/strings.csv
@@ -604,3 +604,76 @@ livello più alto,,highest tier
prossimo,,next
Clic per aprire «La tua scalata»,,Click to open «Your climb»
Scalata,,Climb
+Mesi,,Months
+Anni,,Years
+patrimonio netto,,net worth
+Bancarotta dichiarata,,Bankruptcy declared
+La compagnia non ha riportato la cassa sopra zero entro il limite della difficoltà.,,The company did not bring its cash back above zero within the difficulty limit.
+in corso,,in progress
+finora,,so far
+Voce,,Item
+Utile operativo,,Operating profit
+Flusso di cassa,,Cash flow
+I mesi e gli anni chiusi compaiono qui man mano che passano.,,Closed months and years appear here as they go by.
+"L'utile operativo comprende ricavi e costi d'esercizio; investimenti, prestiti e azioni cambiano solo la cassa.",,"Operating profit includes revenue and operating costs; investments, loans and shares only change cash."
+Costi,,Costs
+Investimenti e finanziamenti,,Investments and financing
+Noli merci,,Freight fares
+Biglietti passeggeri,,Passenger tickets
+Commercio in proprio,,Own trading
+Contratti,,Contracts
+Controllate,,Subsidiaries
+Dividendi incassati,,Dividends received
+Esercizio dei treni,,Train operation
+Manutenzione dei treni,,Train maintenance
+Manutenzione dei binari,,Track maintenance
+Stipendi,,Wages
+Dazi,,Duties
+Magazzini,,Storage
+Penali,,Penalties
+Costruzioni,,Construction
+Acquisto di treni,,Train purchases
+Vendita di treni,,Train sales
+Prestiti ricevuti,,Loans received
+Prestiti rimborsati,,Loans repaid
+Azioni,,Shares
+Dividendi pagati,,Dividends paid
+Altro,,Other
+Rating iniziale: il primo calcolo arriva a inizio mese. Le misure qui sotto sono quelle di oggi.,,Initial rating: the first calculation comes at the start of the month. The measures below are today's.
+Calcolato a inizio mese sugli ultimi,,Calculated at the start of the month over the last
+mese chiuso,,closed month
+mesi chiusi,,closed months
+Punteggio,,Score
+Margine (utile / ricavi),,Margin (profit / revenue)
+patrimonio non positivo,,non-positive equity
+Leva (debiti / patrimonio netto),,Leverage (debt / net worth)
+In bancarotta il rating è D finché la situazione non si risolve.,,While bankrupt the rating is D until the situation is resolved.
+È il rating più alto: i prestiti costano il minimo.,,This is the highest rating: loans cost the least.
+serve migliorare insieme margine e leva,,margin and leverage must improve together
+oppure,,or
+Punteggio da,,Score from
+Tasso,,Rate
+componente,,component
+peso,,weight
+Nessun prestito in corso.,,No loans outstanding.
+Residuo,,Outstanding
+fisso,,fixed
+Rata mensile,,Monthly payment
+interessi,,interest
+scadenza,,maturity
+Estingui,,Pay off
+La cassa è tornata positiva,,Cash is back above zero
+"Dopo {0} di cassa negativa il conto alla rovescia della bancarotta si azzera domani.",,"After {0} of negative cash, the bankruptcy countdown resets tomorrow."
+Cassa negativa da oggi: bancarotta tra {0},,Cash negative since today: bankruptcy in {0}
+Cassa negativa da {0}: bancarotta tra {1},,Cash negative for {0}: bankruptcy in {1}
+"Scoperto {0}. Il limite della difficoltà è di {1}; riporta la cassa sopra zero con un prestito, vendendo treni o riducendo i costi.",,"Overdraft {0}. The difficulty limit is {1}; bring cash back above zero with a loan, by selling trains or by cutting costs."
+neutro,,neutral
+"Il margine conta da quando ci sono almeno {0} mesi chiusi con ricavi (ora {1}): fino ad allora vale 0, così i primi incassi non fanno crollare il rating.",,"The margin counts once there are at least {0} closed months with revenue (now {1}): until then it is 0, so the first takings do not sink the rating."
+"Il punteggio {0} vale già {1}: il rating si aggiorna al prossimo calcolo mensile, a inizio mese.",,"The score {0} is already worth {1}: the rating is updated at the next monthly calculation, at the start of the month."
+un margine di almeno {0},,a margin of at least {0}
+una leva non oltre {0},,leverage no higher than {0}
+una leva non oltre {0} (rimborsando {1}),,leverage no higher than {0} (by repaying {1})
+"una leva non oltre {0} (servirebbe rimborsare {1}, più di quanto la cassa consenta oggi)",,"leverage no higher than {0} (it would take repaying {1}, more than cash allows today)"
+Per il gradino {0} serve un punteggio di {1}: {2}.,,To reach {0} you need a score of {1}: {2}.
+In bancarotta non si possono chiedere prestiti,,Loans cannot be requested while bankrupt
+Fido disponibile {0} su {1}. Tasso di un nuovo prestito: {2} fisso (base {3} + rating {4} {5}) per {6} anni.,,Available credit {0} of {1}. Rate of a new loan: {2} fixed (base {3} + rating {4} {5}) for {6} years.
diff --git a/client/RailEnterprise.Client/scripts/App/AutoPilot.cs b/client/RailEnterprise.Client/scripts/App/AutoPilot.cs
index ad3bb76..7394a92 100644
--- a/client/RailEnterprise.Client/scripts/App/AutoPilot.cs
+++ b/client/RailEnterprise.Client/scripts/App/AutoPilot.cs
@@ -245,6 +245,11 @@ public partial class AutoPilot : Node
await Until(() => World.Climb is not null, "quadro della scalata", 30);
await Shot("17_scalata", 40);
+ // Finanze: conto economico per voce, rating spiegato, prestiti
+ _game.OpenFinance();
+ await Until(() => World.Finance is not null, "quadro delle finanze", 30);
+ await Shot("18_finanze", 40);
+
// Cronaca provvisoria
_game.OpenChronicle();
await Until(() => _game.ChronicleVisible, "cronaca", 30);
diff --git a/client/RailEnterprise.Client/scripts/Panels/ClimbPanel.cs b/client/RailEnterprise.Client/scripts/Panels/ClimbPanel.cs
index 37c49c8..d0c3bcf 100644
--- a/client/RailEnterprise.Client/scripts/Panels/ClimbPanel.cs
+++ b/client/RailEnterprise.Client/scripts/Panels/ClimbPanel.cs
@@ -363,9 +363,10 @@ public partial class ClimbPanel : VBoxContainer
_repay.Text = $"{T("Rimborsa")} {repay}";
_repay.Disabled = loan is null;
_borrow.Disabled = report is null || !report.LoansAllowed;
+ bool bankrupt = report is not null && _session.World.Companies.TryGetValue(report.Company, out var me) && me.Bankrupt;
_borrow.TooltipText = report is null ? "" : report.LoansAllowed
? $"{T("Fido disponibile")} {report.LoanAvailable} {T("su")} {report.MaxLoan}, {T("al")} {Fmt.Pct(report.NewLoanRate, 1)}"
- : T("In amministrazione controllata non si possono chiedere prestiti");
+ : bankrupt ? T("In bancarotta non si possono chiedere prestiti") : T("In amministrazione controllata non si possono chiedere prestiti");
}
private void Borrow() =>
diff --git a/client/RailEnterprise.Client/scripts/Panels/FinancePanel.cs b/client/RailEnterprise.Client/scripts/Panels/FinancePanel.cs
new file mode 100644
index 0000000..960b3c8
--- /dev/null
+++ b/client/RailEnterprise.Client/scripts/Panels/FinancePanel.cs
@@ -0,0 +1,489 @@
+using Godot;
+using RailEnterprise.Client.Net;
+using RailEnterprise.Core.Commands;
+using RailEnterprise.Core.Common;
+using RailEnterprise.Core.Economy;
+using RailEnterprise.Protocol.Client;
+using RailEnterprise.Protocol.Messages;
+using static RailEnterprise.Client.App.Localization;
+using RailEnterprise.Client.App;
+
+namespace RailEnterprise.Client.Panels;
+
+///
+/// «Finanze» a tutto schermo (palette 05, stile del pannello 08): a sinistra il conto economico per
+/// voce con le colonne del mese in corso, dei mesi chiusi e dell'anno (o degli anni chiusi); a destra
+/// il rating con la sua spiegazione, i prestiti con rimborso e richiesta, e, se la cassa è negativa, la
+/// barra dei giorni che restano prima della bancarotta. Tutti i numeri arrivano dal server
+/// (FinanceReport, ADR 0019): il pannello li chiede all'apertura, a ogni nuovo giorno e dopo un
+/// comando, e li mostra com'è, senza calcolare utili, rating o rate.
+///
+public partial class FinancePanel : VBoxContainer
+{
+ /// Mesi chiusi e anni chiusi mostrati accanto alla colonna in corso.
+ private const int ClosedColumns = 5;
+
+ private readonly GameSession _session;
+ private readonly Label _subtitle = UiTheme.Text("", 14, Palette.TextSecondary);
+ private readonly Label _cash = UiTheme.Text("", 30, Palette.AmberLight, bold: true);
+ private readonly PanelContainer _danger = new() { SizeFlagsHorizontal = SizeFlags.ExpandFill, Visible = false };
+ private readonly Label _dangerText = UiTheme.Text("", 15, Palette.Danger, bold: true);
+ private readonly ProgressBar _dangerBar = new() { MinValue = 0, MaxValue = 1, Step = 0.001, ShowPercentage = false, CustomMinimumSize = new Vector2(0, 10) };
+ private readonly Label _dangerDetail = UiTheme.Text("", 13, Palette.TextSecondary);
+ private readonly Button _months = new() { Text = "", ToggleMode = true, ButtonPressed = true, CustomMinimumSize = new Vector2(90, 36) };
+ private readonly Button _years = new() { Text = "", ToggleMode = true, CustomMinimumSize = new Vector2(90, 36) };
+ private readonly GridContainer _table = new() { SizeFlagsHorizontal = SizeFlags.ExpandFill };
+ private readonly Label _tableNote = UiTheme.Text("", 12, Palette.TextSecondary);
+ private readonly Label _rating = UiTheme.TitleLabel("", 56, Palette.AmberLight);
+ private readonly Label _ratingCaption = UiTheme.Text("", 13, Palette.TextSecondary);
+ private readonly VBoxContainer _ratingBody = PanelKit.Column(6);
+ private readonly VBoxContainer _loans = PanelKit.Column(8);
+ private readonly Label _credit = UiTheme.Text("", 13, Palette.TextSecondary);
+ private readonly SpinBox _amount = new() { MinValue = 1_000, MaxValue = 100_000_000, Step = 1_000, Value = 50_000, Prefix = "₤", CustomMinimumSize = new Vector2(150, 0) };
+ private readonly Button _borrow = new() { Text = "", CustomMinimumSize = new Vector2(0, 44), SizeFlagsHorizontal = SizeFlags.ExpandFill };
+ private readonly Label _status = UiTheme.Text("", 12, Palette.TextSecondary);
+ private FinanceReport? _shown;
+ private long _requestedDay = long.MinValue;
+ private double _sinceRequest = double.MaxValue;
+
+ public event Action? CloseRequested;
+
+ public FinancePanel(GameSession session)
+ {
+ _session = session;
+ AddThemeConstantOverride("separation", 16);
+ SizeFlagsVertical = SizeFlags.ExpandFill;
+
+ var header = PanelKit.Row(24);
+ var titles = PanelKit.Column(0);
+ titles.SizeFlagsHorizontal = SizeFlags.ExpandFill;
+ titles.AddChild(UiTheme.TitleLabel(T("Finanze"), 44));
+ titles.AddChild(_subtitle);
+ header.AddChild(titles);
+ var cash = PanelKit.Column(0);
+ cash.SizeFlagsVertical = SizeFlags.ShrinkCenter;
+ var cashCaption = UiTheme.Text(T("Cassa"), 13, Palette.TextSecondary);
+ cashCaption.HorizontalAlignment = HorizontalAlignment.Right;
+ _cash.HorizontalAlignment = HorizontalAlignment.Right;
+ cash.AddChild(cashCaption);
+ cash.AddChild(_cash);
+ header.AddChild(cash);
+ var close = new Button { Text = T("Torna alla mappa"), SizeFlagsVertical = SizeFlags.ShrinkCenter, CustomMinimumSize = new Vector2(170, 48) };
+ close.Pressed += () => CloseRequested?.Invoke();
+ header.AddChild(close);
+ AddChild(header);
+
+ // barra della cassa negativa: giorni passati sul limite della difficoltà
+ _danger.AddThemeStyleboxOverride("panel", UiTheme.Box(Palette.Panel, Palette.Danger, 12, 18));
+ var dangerCol = PanelKit.Column(8);
+ dangerCol.AddChild(_dangerText);
+ _dangerBar.AddThemeStyleboxOverride("background", UiTheme.Box(Palette.Border, Palette.Border, 5, 0));
+ _dangerBar.AddThemeStyleboxOverride("fill", UiTheme.Box(Palette.Danger, Palette.Danger, 5, 0));
+ dangerCol.AddChild(_dangerBar);
+ _dangerDetail.AutowrapMode = TextServer.AutowrapMode.WordSmart;
+ dangerCol.AddChild(_dangerDetail);
+ _danger.AddChild(dangerCol);
+ AddChild(_danger);
+
+ var body = PanelKit.Row(20);
+ body.SizeFlagsVertical = SizeFlags.ExpandFill;
+ AddChild(body);
+
+ // conto economico
+ var left = Column(body, 1.35f);
+ var incomeHeader = PanelKit.Row(8);
+ var incomeTitle = UiTheme.Text(T("Conto economico"), 20, bold: true);
+ incomeTitle.SizeFlagsHorizontal = SizeFlags.ExpandFill;
+ incomeHeader.AddChild(incomeTitle);
+ var group = new ButtonGroup();
+ _months.ButtonGroup = group;
+ _years.ButtonGroup = group;
+ _months.Text = T("Mesi");
+ _years.Text = T("Anni");
+ _months.Pressed += () => RefreshTable(_shown);
+ _years.Pressed += () => RefreshTable(_shown);
+ incomeHeader.AddChild(_months);
+ incomeHeader.AddChild(_years);
+ left.AddChild(incomeHeader);
+ _table.AddThemeConstantOverride("h_separation", 18);
+ _table.AddThemeConstantOverride("v_separation", 6);
+ left.AddChild(_table);
+ _tableNote.AutowrapMode = TextServer.AutowrapMode.WordSmart;
+ left.AddChild(_tableNote);
+
+ // rating e prestiti
+ var right = Column(body, 0.9f);
+ right.AddChild(UiTheme.Text(T("Rating creditizio"), 20, bold: true));
+ var ratingRow = PanelKit.Row(16);
+ ratingRow.AddChild(_rating);
+ _ratingCaption.SizeFlagsVertical = SizeFlags.ShrinkCenter;
+ _ratingCaption.SizeFlagsHorizontal = SizeFlags.ExpandFill;
+ _ratingCaption.AutowrapMode = TextServer.AutowrapMode.WordSmart;
+ ratingRow.AddChild(_ratingCaption);
+ right.AddChild(ratingRow);
+ right.AddChild(_ratingBody);
+ right.AddChild(PanelKit.Separator());
+ right.AddChild(UiTheme.Text(T("Prestiti"), 20, bold: true));
+ right.AddChild(_loans);
+ _credit.AutowrapMode = TextServer.AutowrapMode.WordSmart;
+ right.AddChild(_credit);
+ var loanRow = PanelKit.Row(10);
+ loanRow.AddChild(_amount);
+ loanRow.AddChild(_borrow);
+ right.AddChild(loanRow);
+ _status.AutowrapMode = TextServer.AutowrapMode.WordSmart;
+ right.AddChild(_status);
+ _borrow.Text = T("Chiedi un prestito");
+ _borrow.Pressed += Borrow;
+ _amount.ValueChanged += _ => RefreshLoans(_shown);
+
+ _subtitle.Text = T("In attesa del quadro dal server…");
+ }
+
+ private static VBoxContainer Column(HBoxContainer body, float ratio)
+ {
+ var frame = new PanelContainer { SizeFlagsHorizontal = SizeFlags.ExpandFill, SizeFlagsVertical = SizeFlags.ExpandFill, SizeFlagsStretchRatio = ratio };
+ frame.AddThemeStyleboxOverride("panel", UiTheme.Box(Palette.Panel, Palette.Border, 12, 24));
+ var scroll = new ScrollContainer { HorizontalScrollMode = ScrollContainer.ScrollMode.Auto, SizeFlagsVertical = SizeFlags.ExpandFill };
+ frame.AddChild(scroll);
+ var margin = new MarginContainer { SizeFlagsHorizontal = SizeFlags.ExpandFill, SizeFlagsVertical = SizeFlags.ExpandFill };
+ margin.AddThemeConstantOverride("margin_right", 10);
+ scroll.AddChild(margin);
+ var col = PanelKit.Column(12);
+ col.SizeFlagsVertical = SizeFlags.ExpandFill;
+ margin.AddChild(col);
+ body.AddChild(frame);
+ return col;
+ }
+
+ public override void _Process(double delta)
+ {
+ var w = _session.World;
+ _sinceRequest += delta;
+ // il quadro si chiede all'apertura e a ogni nuovo giorno (di nuovo dopo 5 s se non arriva)
+ long today = Fmt.Today(w);
+ if (today != _requestedDay || (w.Finance is null && _sinceRequest > 5)) Request(today);
+ if (w.Finance is { } report && !ReferenceEquals(report, _shown)) Refresh(w, report);
+ }
+
+ private void Request(long day)
+ {
+ _requestedDay = day;
+ _sinceRequest = 0;
+ _session.Send(new RequestDetail { Kind = DetailKind.Finance, Target = 0 });
+ }
+
+ // ------------------------------------------------------------------ aggiornamento
+
+ private void Refresh(ClientWorld w, FinanceReport report)
+ {
+ _shown = report;
+ _subtitle.Text = $"{Fmt.Company(w, report.Company)} · {Fmt.Date(w, report.Day)} · {T("patrimonio netto")} {report.NetWorth}";
+ _cash.Text = report.Cash.ToString();
+ _cash.AddThemeColorOverride("font_color", report.Cash.IsNegative ? Palette.Danger : Palette.AmberLight);
+ RefreshDanger(report);
+ RefreshTable(report);
+ RefreshRating(report);
+ RefreshLoans(report);
+ }
+
+ ///
+ /// Barra della cassa negativa. Il motore conta i giorni una volta al giorno, quindi dopo un prestito il
+ /// contatore può restare indietro di un giorno rispetto alla cassa: il conto alla rovescia si mostra solo
+ /// con la cassa davvero negativa (scoperto) o in bancarotta.
+ ///
+ private void RefreshDanger(FinanceReport r)
+ {
+ bool overdraft = r.Overdraft.Cents > 0;
+ bool recovering = !overdraft && !r.Bankrupt && r.NegativeCashDays > 0;
+ _danger.Visible = overdraft || r.Bankrupt || recovering;
+ _dangerBar.Visible = overdraft || r.Bankrupt;
+ if (!_danger.Visible) return;
+ _dangerBar.Value = r.BankruptcyDays > 0 ? Math.Clamp((double)r.NegativeCashDays / r.BankruptcyDays, 0, 1) : 1;
+ if (r.Bankrupt)
+ {
+ _dangerText.Text = T("Bancarotta dichiarata");
+ _dangerDetail.Text = T("La compagnia non ha riportato la cassa sopra zero entro il limite della difficoltà.");
+ return;
+ }
+ if (recovering)
+ {
+ _dangerText.Text = T("La cassa è tornata positiva");
+ _dangerDetail.Text = string.Format(T("Dopo {0} di cassa negativa il conto alla rovescia della bancarotta si azzera domani."), Days(r.NegativeCashDays));
+ return;
+ }
+ int left = Math.Max(0, r.BankruptcyDays - r.NegativeCashDays);
+ _dangerText.Text = r.NegativeCashDays == 0
+ ? string.Format(T("Cassa negativa da oggi: bancarotta tra {0}"), Days(r.BankruptcyDays))
+ : string.Format(T("Cassa negativa da {0}: bancarotta tra {1}"), Days(r.NegativeCashDays), Days(left));
+ _dangerDetail.Text = string.Format(T("Scoperto {0}. Il limite della difficoltà è di {1}; riporta la cassa sopra zero con un prestito, vendendo treni o riducendo i costi."),
+ r.Overdraft, Days(r.BankruptcyDays));
+ }
+
+ private static string Days(int n) => n == 1 ? $"1 {T("giorno")}" : $"{n} {T("giorni")}";
+
+ // ------------------------------------------------------------------ conto economico
+
+ private static string[] MonthNames() =>
+ [T("gen"), T("feb"), T("mar"), T("apr"), T("mag"), T("giu"), T("lug"), T("ago"), T("set"), T("ott"), T("nov"), T("dic")];
+
+ /// Colonne da mostrare: il mese in corso e i mesi chiusi, poi l'anno in corso; oppure l'anno in corso e gli anni chiusi.
+ private List ShownColumns(FinanceReport r)
+ {
+ if (_years.ButtonPressed)
+ {
+ return r.Columns.Where(c => c.Kind == IncomeColumnInfo.CurrentYear)
+ .Concat(r.Columns.Where(c => c.Kind == IncomeColumnInfo.ClosedYear).Take(ClosedColumns)).ToList();
+ }
+ return r.Columns.Where(c => c.Kind == IncomeColumnInfo.CurrentMonth)
+ .Concat(r.Columns.Where(c => c.Kind == IncomeColumnInfo.ClosedMonth).Take(ClosedColumns))
+ .Concat(r.Columns.Where(c => c.Kind == IncomeColumnInfo.CurrentYear)).ToList();
+ }
+
+ private static string ColumnTitle(IncomeColumnInfo c)
+ {
+ string month = c.Month is >= 1 and <= 12 ? MonthNames()[c.Month - 1] : "";
+ return c.Kind switch
+ {
+ IncomeColumnInfo.CurrentMonth => $"{month} {c.Year}\n{T("in corso")}",
+ IncomeColumnInfo.ClosedMonth => $"{month} {c.Year}\n ",
+ IncomeColumnInfo.CurrentYear => $"{c.Year}\n{T("finora")}",
+ _ => $"{c.Year}\n ",
+ };
+ }
+
+ private void RefreshTable(FinanceReport? r)
+ {
+ foreach (var c in _table.GetChildren()) c.QueueFree();
+ if (r is null) return;
+ var columns = ShownColumns(r);
+ _table.Columns = columns.Count + 1;
+ Cell(T("Voce"), Palette.TextSecondary, bold: true, left: true);
+ foreach (var c in columns)
+ Cell(ColumnTitle(c), c.Kind is IncomeColumnInfo.CurrentMonth or IncomeColumnInfo.CurrentYear ? Palette.AmberLight : Palette.TextSecondary, bold: true);
+
+ foreach (byte section in new[] { FinanceLineInfo.SectionRevenue, FinanceLineInfo.SectionCost, FinanceLineInfo.SectionCapital })
+ {
+ // le voci sempre a zero nelle colonne mostrate non occupano righe
+ var lines = r.Lines.Where(l => l.Section == section && columns.Any(c => c.Value(l.Kind).Cents != 0)).ToList();
+ if (lines.Count == 0) continue;
+ Cell(SectionName(section), Palette.Amber, bold: true, left: true);
+ foreach (var _ in columns) Cell("", Palette.Text);
+ foreach (var line in lines)
+ {
+ Cell(EntryName((LedgerEntry)line.Kind), Palette.Text, left: true, indent: true);
+ foreach (var c in columns)
+ {
+ var v = c.Value(line.Kind);
+ Cell(v.Cents == 0 ? "—" : v.ToString(), v.IsNegative ? Palette.Danger : v.Cents == 0 ? Palette.TextSecondary : Palette.Text);
+ }
+ }
+ if (section == FinanceLineInfo.SectionCost)
+ {
+ Cell(T("Utile operativo"), Palette.Text, bold: true, left: true);
+ foreach (var c in columns) Cell(c.Profit.ToString(), c.Profit.IsNegative ? Palette.Danger : Palette.AmberLight, bold: true);
+ }
+ }
+ Cell(T("Flusso di cassa"), Palette.Text, bold: true, left: true);
+ foreach (var c in columns) Cell(c.CashFlow.ToString(), c.CashFlow.IsNegative ? Palette.Danger : Palette.Ok, bold: true);
+ _tableNote.Text = columns.Count <= 1
+ ? T("I mesi e gli anni chiusi compaiono qui man mano che passano.")
+ : T("L'utile operativo comprende ricavi e costi d'esercizio; investimenti, prestiti e azioni cambiano solo la cassa.");
+ }
+
+ private void Cell(string text, Color color, bool bold = false, bool left = false, bool indent = false)
+ {
+ var l = UiTheme.Text(indent ? " " + text : text, 14, color, bold);
+ l.HorizontalAlignment = left ? HorizontalAlignment.Left : HorizontalAlignment.Right;
+ if (left) l.SizeFlagsHorizontal = SizeFlags.ExpandFill;
+ else l.CustomMinimumSize = new Vector2(110, 0);
+ _table.AddChild(l);
+ }
+
+ private static string SectionName(byte section) => section switch
+ {
+ FinanceLineInfo.SectionRevenue => T("Ricavi"),
+ FinanceLineInfo.SectionCost => T("Costi"),
+ _ => T("Investimenti e finanziamenti"),
+ };
+
+ /// Nome della voce del registro nella lingua dell'interfaccia.
+ public static string EntryName(LedgerEntry e) => e switch
+ {
+ LedgerEntry.FreightRevenue => T("Noli merci"),
+ LedgerEntry.PassengerRevenue => T("Biglietti passeggeri"),
+ LedgerEntry.Trading => T("Commercio in proprio"),
+ LedgerEntry.Contracts => T("Contratti"),
+ LedgerEntry.Industries => T("Industrie possedute"),
+ LedgerEntry.Subsidiaries => T("Controllate"),
+ LedgerEntry.DividendsReceived => T("Dividendi incassati"),
+ LedgerEntry.RunningCosts => T("Esercizio dei treni"),
+ LedgerEntry.StationUpkeep => T("Stazioni e depositi"),
+ LedgerEntry.FleetMaintenance => T("Manutenzione dei treni"),
+ LedgerEntry.TrackMaintenance => T("Manutenzione dei binari"),
+ LedgerEntry.Wages => T("Stipendi"),
+ LedgerEntry.Interest => T("Interessi"),
+ LedgerEntry.Duties => T("Dazi"),
+ LedgerEntry.Storage => T("Magazzini"),
+ LedgerEntry.Penalties => T("Penali"),
+ LedgerEntry.Construction => T("Costruzioni"),
+ LedgerEntry.VehiclePurchase => T("Acquisto di treni"),
+ LedgerEntry.VehicleSale => T("Vendita di treni"),
+ LedgerEntry.IndustryPurchase => T("Acquisto di industrie"),
+ LedgerEntry.LoanTaken => T("Prestiti ricevuti"),
+ LedgerEntry.LoanRepaid => T("Prestiti rimborsati"),
+ LedgerEntry.Shares => T("Azioni"),
+ LedgerEntry.Dividends => T("Dividendi pagati"),
+ _ => T("Altro"),
+ };
+
+ // ------------------------------------------------------------------ rating
+
+ private static string Ratio(double value) => Fmt.Number(value, 2);
+
+ private void RefreshRating(FinanceReport r)
+ {
+ _rating.Text = r.Rating;
+ _ratingCaption.Text = r.RatingInitial
+ ? T("Rating iniziale: il primo calcolo arriva a inizio mese. Le misure qui sotto sono quelle di oggi.")
+ : $"{T("Calcolato a inizio mese sugli ultimi")} {r.RatingMonths} {(r.RatingMonths == 1 ? T("mese chiuso") : T("mesi chiusi"))}. "
+ + $"{T("Punteggio")} {Ratio(r.Score)}.";
+ foreach (var c in _ratingBody.GetChildren()) c.QueueFree();
+
+ _ratingBody.AddChild(Measure(T("Margine (utile / ricavi)"), r.MarginNeutral ? T("neutro") : Fmt.Pct(r.Margin, 1), r.MarginWeight, r.MarginComponent));
+ if (r.MarginNeutral)
+ _ratingBody.AddChild(Note(string.Format(T("Il margine conta da quando ci sono almeno {0} mesi chiusi con ricavi (ora {1}): fino ad allora vale 0, così i primi incassi non fanno crollare il rating."),
+ r.MinRevenueMonths, r.RevenueMonths)));
+ string leverage = r.LeverageUnbounded ? T("patrimonio non positivo") : Ratio(r.Leverage);
+ _ratingBody.AddChild(Measure(T("Leva (debiti / patrimonio netto)"), leverage, r.LeverageWeight, r.LeverageComponent));
+
+ if (r.Bankrupt)
+ {
+ _ratingBody.AddChild(Note(T("In bancarotta il rating è D finché la situazione non si risolve.")));
+ }
+ else if (r.NextRating.Length == 0)
+ {
+ _ratingBody.AddChild(Note(T("È il rating più alto: i prestiti costano il minimo.")));
+ }
+ else if (r.NextAlreadyMet)
+ {
+ _ratingBody.AddChild(Note(string.Format(T("Il punteggio {0} vale già {1}: il rating si aggiorna al prossimo calcolo mensile, a inizio mese."),
+ Ratio(r.Score), r.ScoreRating)));
+ }
+ else
+ {
+ var ways = new List();
+ if (r.MarginReachable) ways.Add(string.Format(T("un margine di almeno {0}"), Fmt.Pct(r.MarginNeeded, 1)));
+ if (r.LeverageReachable)
+ {
+ string way = r.DebtToRepay.Cents <= 0 ? T("una leva non oltre {0}")
+ : r.RepayAffordable ? T("una leva non oltre {0} (rimborsando {1})")
+ : T("una leva non oltre {0} (servirebbe rimborsare {1}, più di quanto la cassa consenta oggi)");
+ ways.Add(string.Format(way, Ratio(r.LeverageMax), r.DebtToRepay));
+ }
+ string how = ways.Count == 0 ? T("serve migliorare insieme margine e leva") : string.Join($" {T("oppure")} ", ways);
+ _ratingBody.AddChild(Note(string.Format(T("Per il gradino {0} serve un punteggio di {1}: {2}."), r.NextRating, Ratio(r.NextThreshold), how)));
+ }
+
+ // soglie e tassi per rating
+ var grid = new GridContainer { Columns = 3 };
+ grid.AddThemeConstantOverride("h_separation", 24);
+ grid.AddChild(UiTheme.Text(T("Rating"), 12, Palette.TextSecondary, bold: true));
+ grid.AddChild(UiTheme.Text(T("Punteggio da"), 12, Palette.TextSecondary, bold: true));
+ grid.AddChild(UiTheme.Text(T("Tasso"), 12, Palette.TextSecondary, bold: true));
+ foreach (var t in r.Thresholds)
+ {
+ bool current = t.Rating == r.Rating;
+ var color = current ? Palette.AmberLight : Palette.TextSecondary;
+ grid.AddChild(UiTheme.Text(t.Rating, 12, color, current));
+ grid.AddChild(UiTheme.Text(Ratio(t.MinScore), 12, color, current));
+ grid.AddChild(UiTheme.Text(Fmt.Pct(t.LoanRate, 1), 12, color, current));
+ }
+ _ratingBody.AddChild(grid);
+ }
+
+ private static Control Measure(string caption, string value, float weight, float component)
+ {
+ var col = PanelKit.Column(4);
+ var row = PanelKit.Row(8);
+ var c = UiTheme.Text(caption, 14, Palette.Text);
+ c.SizeFlagsHorizontal = SizeFlags.ExpandFill;
+ row.AddChild(c);
+ row.AddChild(UiTheme.Text(value, 14, Palette.Text, bold: true));
+ col.AddChild(row);
+ var bar = new ProgressBar { MinValue = 0, MaxValue = 1, Step = 0.001, Value = Math.Clamp(component, 0, 1), ShowPercentage = false, CustomMinimumSize = new Vector2(0, 6) };
+ bar.AddThemeStyleboxOverride("background", UiTheme.Box(Palette.Border, Palette.Border, 3, 0));
+ bar.AddThemeStyleboxOverride("fill", UiTheme.Box(Palette.Amber, Palette.Amber, 3, 0));
+ col.AddChild(bar);
+ col.AddChild(UiTheme.Text($"{T("componente")} {Ratio(component)} × {T("peso")} {Ratio(weight)}", 12, Palette.TextSecondary));
+ return col;
+ }
+
+ private static Label Note(string text)
+ {
+ var l = UiTheme.Text(text, 13, Palette.Text);
+ l.AutowrapMode = TextServer.AutowrapMode.WordSmart;
+ return l;
+ }
+
+ // ------------------------------------------------------------------ prestiti (comandi al server)
+
+ private Money Amount => Money.FromLire((long)_amount.Value);
+
+ private void RefreshLoans(FinanceReport? r)
+ {
+ foreach (var c in _loans.GetChildren()) c.QueueFree();
+ if (r is null) return;
+ var w = _session.World;
+ if (r.LoanList.Count == 0) _loans.AddChild(UiTheme.Text(T("Nessun prestito in corso."), 13, Palette.TextSecondary));
+ foreach (var loan in r.LoanList)
+ {
+ var card = new PanelContainer { SizeFlagsHorizontal = SizeFlags.ExpandFill };
+ card.AddThemeStyleboxOverride("panel", UiTheme.Box(Palette.Inner, Palette.Border, 8, 12));
+ var col = PanelKit.Column(4);
+ var head = PanelKit.Row(8);
+ var title = UiTheme.Text($"{T("Residuo")} {loan.Remaining} {T("su")} {loan.Principal}", 14, Palette.Text, bold: true);
+ title.SizeFlagsHorizontal = SizeFlags.ExpandFill;
+ head.AddChild(title);
+ head.AddChild(UiTheme.Text($"{Fmt.Pct(loan.AnnualRate, 1)} {T("fisso")}", 14, Palette.AmberLight, bold: true));
+ col.AddChild(head);
+ col.AddChild(UiTheme.Text(
+ $"{T("Rata mensile")} {loan.Payment} ({T("interessi")} {loan.NextInterest}) · {loan.MonthsLeft} {T("mesi")} · {T("scadenza")} {Fmt.Date(w, loan.MaturityDay)}",
+ 12, Palette.TextSecondary));
+ var buttons = PanelKit.Row(8);
+ var part = Money.Min(Amount, loan.Remaining);
+ var repay = new Button { Text = $"{T("Rimborsa")} {part}", CustomMinimumSize = new Vector2(0, 34), SizeFlagsHorizontal = SizeFlags.ExpandFill };
+ repay.Disabled = part >= loan.Remaining;
+ int id = loan.Loan;
+ repay.Pressed += () => Repay(id, part);
+ var all = new Button { Text = $"{T("Estingui")} ({loan.Remaining})", CustomMinimumSize = new Vector2(0, 34), SizeFlagsHorizontal = SizeFlags.ExpandFill };
+ var remaining = loan.Remaining;
+ all.Pressed += () => Repay(id, remaining);
+ buttons.AddChild(repay);
+ buttons.AddChild(all);
+ col.AddChild(buttons);
+ card.AddChild(col);
+ _loans.AddChild(card);
+ }
+
+ _borrow.Disabled = !r.LoansAllowed || r.LoanAvailable.Cents <= 0;
+ _credit.Text = r.Bankrupt ? T("In bancarotta non si possono chiedere prestiti")
+ : r.Receivership ? T("In amministrazione controllata non si possono chiedere prestiti")
+ : string.Format(T("Fido disponibile {0} su {1}. Tasso di un nuovo prestito: {2} fisso (base {3} + rating {4} {5}) per {6} anni."),
+ r.LoanAvailable, r.MaxLoan, Fmt.Pct(r.NewLoanRate, 1), Fmt.Pct(r.BaseRate, 1), r.Rating, Fmt.Pct(r.Spread, 1), r.LoanTermMonths / 12);
+ }
+
+ private void Borrow() =>
+ _session.Command(new TakeLoanCommand(Amount), r =>
+ {
+ _status.Text = r.Message;
+ Request(Fmt.Today(_session.World));
+ });
+
+ private void Repay(int loan, Money amount) =>
+ _session.Command(new RepayLoanCommand(new LoanId(loan), amount), r =>
+ {
+ _status.Text = r.Message;
+ Request(Fmt.Today(_session.World));
+ });
+}
diff --git a/client/RailEnterprise.Client/scripts/Panels/SimplePanels.cs b/client/RailEnterprise.Client/scripts/Panels/SimplePanels.cs
index 0fc883f..37994f2 100644
--- a/client/RailEnterprise.Client/scripts/Panels/SimplePanels.cs
+++ b/client/RailEnterprise.Client/scripts/Panels/SimplePanels.cs
@@ -77,41 +77,3 @@ public partial class HelpPanel : VBoxContainer
AddChild(l);
}
}
-
-/// Conti della compagnia e prestiti.
-public partial class FinancePanel : VBoxContainer
-{
- private readonly GameSession _session;
- private readonly Label _cash = PanelKit.Value();
- private readonly Label _worth = PanelKit.Value();
- private readonly Label _rating = PanelKit.Value();
- private readonly SpinBox _loan = new() { MinValue = 10_000, MaxValue = 10_000_000, Step = 10_000, Value = 100_000, Prefix = "₤", SizeFlagsHorizontal = SizeFlags.ExpandFill };
- private readonly Label _status = UiTheme.Text("", 13, Palette.TextSecondary);
-
- public FinancePanel(GameSession session)
- {
- _session = session;
- AddThemeConstantOverride("separation", 10);
- AddChild(UiTheme.TitleLabel(T("Finanze"), 34));
- AddChild(PanelKit.Pair(T("Cassa"), _cash));
- AddChild(PanelKit.Pair(T("Patrimonio netto"), _worth));
- AddChild(PanelKit.Pair(T("Rating"), _rating));
- AddChild(PanelKit.Separator());
- AddChild(UiTheme.Text(T("Prestito"), 14, bold: true));
- AddChild(_loan);
- var take = UiTheme.Primary(T("Chiedi il prestito"));
- take.Pressed += () => _session.Command(new TakeLoanCommand(Money.FromLire((long)_loan.Value)), r => _status.Text = r.Message);
- AddChild(take);
- _status.AutowrapMode = TextServer.AutowrapMode.WordSmart;
- AddChild(_status);
- }
-
- public override void _Process(double delta)
- {
- var w = _session.World;
- var me = w.Summary is null ? null : w.Companies.GetValueOrDefault(w.Summary.CompanyId);
- _cash.Text = (w.LastDigest?.Cash ?? me?.Cash ?? default).ToString();
- _worth.Text = (w.LastDigest?.NetWorth ?? me?.NetWorth ?? default).ToString();
- _rating.Text = w.LastDigest?.Rating ?? me?.Rating ?? "—";
- }
-}
diff --git a/client/RailEnterprise.Client/scripts/Screens/GameScreen.cs b/client/RailEnterprise.Client/scripts/Screens/GameScreen.cs
index b7e403a..581af93 100644
--- a/client/RailEnterprise.Client/scripts/Screens/GameScreen.cs
+++ b/client/RailEnterprise.Client/scripts/Screens/GameScreen.cs
@@ -44,6 +44,7 @@ public partial class GameScreen : Node
private CompaniesPanel? _companies;
private MarketPanel? _market;
private ClimbPanel? _climb;
+ private FinancePanel? _finance;
// pannelli a tutto schermo (Compagnie e borsa, Mercato globale): coprono mappa e pannello destro, la barra resta
private readonly PanelContainer _full = new() { SizeFlagsHorizontal = Control.SizeFlags.ExpandFill, Visible = false };
private Control? _mapArea;
@@ -124,6 +125,12 @@ public partial class GameScreen : Node
if (_tool != Tool.Climb) _toolbar.Select(Tool.Climb);
}
+ /// Apre le «Finanze» a tutto schermo: conto economico, rating e prestiti.
+ public void OpenFinance()
+ {
+ if (_tool != Tool.Finance) _toolbar.Select(Tool.Finance);
+ }
+
/// Dal Mercato globale: strumento binari con la mappa centrata sull'hub da collegare.
private void PlanLineToHub(int hub)
{
@@ -402,8 +409,9 @@ public partial class GameScreen : Node
_companies = null;
_market = null;
_climb = null;
+ _finance = null;
foreach (var c in _full.GetChildren()) c.QueueFree();
- bool full = tool is Tool.Companies or Tool.Market or Tool.Climb;
+ bool full = tool is Tool.Companies or Tool.Market or Tool.Climb or Tool.Finance;
_full.Visible = full;
if (_mapArea is not null) _mapArea.Visible = !full;
if (_side is not null) _side.Visible = !full;
@@ -480,7 +488,10 @@ public partial class GameScreen : Node
panel = NewInfoPanel();
break;
case Tool.Finance:
- panel = new FinancePanel(_session);
+ _finance = new FinancePanel(_session);
+ _finance.CloseRequested += () => _toolbar.Select(Tool.None);
+ _full.AddChild(_finance);
+ panel = NewInfoPanel();
break;
default:
panel = NewInfoPanel();
diff --git a/data/balance.json b/data/balance.json
index c4269d7..1c813d6 100644
--- a/data/balance.json
+++ b/data/balance.json
@@ -139,7 +139,12 @@
"loanStep": 5000000,
"startingRating": "BB",
"depreciationYearsTrack": 50,
- "bookValueFloor": 0.1
+ "bookValueFloor": 0.1,
+ "incomeMonths": 12,
+ "incomeYears": 10,
+ "bankruptcyWarningDaysLeft": [ 30, 14, 7, 3, 1 ],
+ "ratingMinRevenueMonths": 3,
+ "negativeCashNoticeDays": 3
},
"stockMarket": {
"shares": 1000000,
diff --git a/docs/ARCHITECTURE.md b/docs/ARCHITECTURE.md
index a6f7777..ac549e8 100644
--- a/docs/ARCHITECTURE.md
+++ b/docs/ARCHITECTURE.md
@@ -60,7 +60,7 @@ Sistemi implementati (F1–F5), nella loro posizione:
| `IndustryMaintenanceSystem` | giorno/mese | condizione degli impianti (usura con l'utilizzo, recupero del budget), consumo di ricambi, fermi e incidenti, revisioni e ammodernamenti in attesa di macchinari, scelte dei proprietari privati, conguaglio con il proprietario (ADR 0011) |
| `TownSystem` | giorno/mese/anno | consumo e soddisfazione, crescita, migrazione, espansione dell'abitato |
| `MarketSystem` | giorno | prezzi globali con componente mondiale e shock, domanda insoddisfatta |
-| `FinanceSystem` | giorno/mese/anno | costi di esercizio di veicoli, stazioni e depositi, valori di libro per voce (`BookValues`, ADR 0018), cassa negativa e bancarotta, rate dei prestiti, rating, livelli (`Tiers`), utile mensile nell'anello dei 12 mesi, chiusura dei conti |
+| `FinanceSystem` | giorno/mese/anno | costi di esercizio dei veicoli (`RunningCosts`) e di stazioni e depositi (`StationUpkeep`), stipendi del personale presente nei depositi (`Wages`), valori di libro per voce (`BookValues`, ADR 0018), cassa negativa con gli avvisi e bancarotta ai giorni della difficoltà, rate dei prestiti a tasso fisso, chiusura del mese nel conto economico per voce (`IncomeMonths`, `IncomeYears`) e nell'anello dei 12 mesi, rating da margine (12 mesi) e leva (debiti / patrimonio) con le misure conservate, livelli (`Tiers`), chiusura dei conti (ADR 0019) |
| `StockMarketSystem` | giorno/mese/anno | prezzi e sentiment, valore delle partecipazioni, offerte pubbliche (adesioni, esito), controllo e utili delle controllate, amministrazione controllata del giocatore, fallimenti e aste, storico annuale, nuovi concorrenti (ADR 0012) |
| `AiSystem` | giorno/mese | agenti delle compagnie IA: progetti, stalli, offerte; una volta al mese (giorno diverso per IA) finanza, treni aggiuntivi, borsa, industrie, linee dei ricambi e nuovi progetti, tutto con i comandi (ADR 0013) |
| `EventSystem` | giorno | eventi del mondo (F6, ADR 0017): chiude quelli scaduti, estrae i nuovi dal catalogo `events.json` con il flusso «events» e la frequenza della difficoltà, notizie d'inizio e di fine (posto di «Events») |
@@ -92,8 +92,8 @@ Requisito: stesso seme + stessi comandi agli stessi tick ⇒ stesso hash di stat
## 6. Economia e contabilità
-- Entità in `RailEnterprise.Core.Economy`: `Town`, `Industry`, `Hub`, `ResourceSite`, `Company` (con `Loan`), `CommuteContract`, `Market`, `Tariffs`; `MarketOutlook` (F6, ADR 0015) è l'analisi in sola lettura per il pannello «Mercato globale»: storico mensile, previsione dalla componente mondiale, destinazioni di vendita, hub, evento in corso, avanzamento verso il commercio. `ClimbOutlook` (F6, ADR 0018) è l'analisi in sola lettura per «La tua scalata»: livelli con gli sblocchi dai dati (`Tiers.NewUnlocks`), requisiti del prossimo livello con l'avanzamento (media delle tre frazioni, usata anche dal Mercato globale), stato patrimoniale per voce che somma al patrimonio netto del motore, conto economico, prestiti, storico del patrimonio dalla Cronaca.
-- Ogni movimento di denaro passa dal registro (`MoneyLedger.Transfer`) tra conti: compagnie, industrie e il conto `Esterno` (famiglie, clienti delle tariffe, mercato mondiale). La somma di tutti i saldi è sempre zero: è l'invariante «denaro» dei test. Le voci del conto economico delle compagnie (`LedgerEntry`) si accumulano per mese e per anno.
+- Entità in `RailEnterprise.Core.Economy`: `Town`, `Industry`, `Hub`, `ResourceSite`, `Company` (con `Loan`), `CommuteContract`, `Market`, `Tariffs`; `MarketOutlook` (F6, ADR 0015) è l'analisi in sola lettura per il pannello «Mercato globale»: storico mensile, previsione dalla componente mondiale, destinazioni di vendita, hub, evento in corso, avanzamento verso il commercio. `ClimbOutlook` (F6, ADR 0018) è l'analisi in sola lettura per «La tua scalata»: livelli con gli sblocchi dai dati (`Tiers.NewUnlocks`), requisiti del prossimo livello con l'avanzamento (media delle tre frazioni, usata anche dal Mercato globale), stato patrimoniale per voce che somma al patrimonio netto del motore, conto economico, prestiti, storico del patrimonio dalla Cronaca. `FinanceOutlook` (F6, ADR 0019) è l'analisi in sola lettura per il pannello «Finanze»: conto economico per voce (mese in corso, mesi chiusi, anno in corso, anni chiusi) che somma all'utile operativo del motore, spiegazione del rating (misure, componenti, soglie, cosa serve per salire), prestiti con rata e scadenza, fido, giorni di cassa negativa sul limite della difficoltà.
+- Ogni movimento di denaro passa dal registro (`MoneyLedger.Transfer`) tra conti: compagnie, industrie e il conto `Esterno` (famiglie, clienti delle tariffe, mercato mondiale). La somma di tutti i saldi è sempre zero: è l'invariante «denaro» dei test. Le voci del conto economico delle compagnie (`LedgerEntry`) si accumulano per mese e per anno; `LedgerEntries` ne fissa l'ordine e le sezioni (ricavi, costi, investimenti e finanziamenti) e `Company.OperatingProfit` è la somma di ricavi e costi (ADR 0019). Un trasferimento può usare voci diverse per chi paga e chi incassa (dividendi pagati e incassati).
- Ogni unità di merce sta in un magazzino tracciato (industrie, città, magazzini delle compagnie nelle stazioni, pacchetti in stazione e a bordo dei treni) e `GoodsCounters` registra prodotto, consumato, deperito, importato, esportato: giacenza = prodotto + importato − consumato − deperito − esportato. È l'invariante «merci».
- Compravendita in proprio (F6, ADR 0016): `TradingCommandHandlers` esegue `BuyGoods`, `SellGoods` e `ShipGoods` con il prezzo locale marginale di `Systems/TradingMath` (unità per unità, controparti ordinate per prezzo). La merce comprata sta in `Station.Stock`; quella spedita viaggia in pacchetti con `Packet.Owned`, senza tariffa né consumatore, ed entra nel magazzino della stazione d'arrivo. Gli scambi con le industrie passano dal registro sulla voce «Commercio», quelli con gli hub contano come importazione ed esportazione; `StationSystem` addebita ogni mese la giacenza dei magazzini.
- Eventi del mondo (F6, ADR 0017): `World.WorldEvents` (`WorldEventState`) è l'unica sorgente dei loro effetti. I sistemi chiedono un moltiplicatore per entità (1 senza eventi): `IndustryCapacity` in `IndustrySystem` e nella domanda di input di `DemandSystem`, `TownDemand` in `DemandSystem.TownDemand`, `Attendance` nelle presenze dei pendolari di `EmploymentSystem`, `EdgeSpeed` in `TrainSystem` ed `EdgeWear` nell'usura del binario di `ConstructionSystem` (traffico del giorno prima). Contano solo gli eventi in vigore nel giorno dell'orologio, [inizio, fine). Nessuno stato di base viene modificato: a evento finito il moltiplicatore torna 1. Le stime dei candidati delle IA leggono i valori senza eventi.
@@ -109,6 +109,7 @@ Requisito: stesso seme + stessi comandi agli stessi tick ⇒ stesso hash di stat
- Corpo versione 4 (F6): `TradingSerializer` aggiunge i magazzini delle compagnie nelle stazioni (beni per id testuale) e gli id dei pacchetti di merce propria in stazione e a bordo; i salvataggi precedenti si caricano con i magazzini vuoti. `WorldSerializer.Write(w, s, versione)` scrive un corpo di una versione precedente per i test di migrazione (ADR 0016).
- Corpo versione 5 (F6): `EventSerializer` aggiunge il prossimo id e gli eventi del mondo attivi (tipo e bene per id testuale, bersaglio, giorni, intensità; la zona si ricalcola dal catalogo); le impostazioni salvano `eventFrequencyMultiplier`. I salvataggi precedenti si caricano senza eventi e con la frequenza del preset (ADR 0017).
- Corpo versione 6 (F6): `BalanceSheetSerializer` aggiunge per ogni compagnia il valore contabile per voce (`AssetCategory`) e il giorno in cui ha raggiunto ogni livello. I salvataggi precedenti ripartiscono il totale salvato in proporzione alle voci calcolate al caricamento (stesso patrimonio netto) e ricostruiscono i giorni dai fatti salienti o dallo storico (ADR 0018).
+- Corpo versione 7 (F6): `FinanceSerializer` aggiunge per ogni compagnia i mesi e gli anni chiusi per voce del registro e le misure dell'ultimo calcolo del rating. I salvataggi precedenti partono senza mesi chiusi, con l'ultimo anno chiuso dal registro e la spiegazione del rating sulle misure del giorno fino al primo calcolo mensile (ADR 0019).
## 8. Server
diff --git a/docs/PROTOCOL.md b/docs/PROTOCOL.md
index 3a32720..c067a32 100644
--- a/docs/PROTOCOL.md
+++ b/docs/PROTOCOL.md
@@ -77,7 +77,7 @@ costMultiplier: f64 }`
| 7 | Save | `name: string` |
| 8 | Load | `saveId: string` |
| 9 | NewGame | `seed: u64`, `sizeKm: i32`, `startYear: i32` (0 = predefinito), `difficultyPreset: string`, `overrides: [(key: string, value: f64)]`, `endlessFlags: u32` |
-| 10 | RequestDetail | `kind: u8` (1 cartella di manutenzione di un treno, 2 registro officina di un deposito, 3 registro degli impieghi; dalla F5: 4 scheda di una compagnia, 5 scheda di un'industria, 6 Cronaca; dalla F6: 7 quadro del mercato globale, 8 quadro della scalata), `target: i32` (id del treno, del deposito, della compagnia o dell'industria; ignorato per 3, 6, 7 e 8). Aggiunto in F4 |
+| 10 | RequestDetail | `kind: u8` (1 cartella di manutenzione di un treno, 2 registro officina di un deposito, 3 registro degli impieghi; dalla F5: 4 scheda di una compagnia, 5 scheda di un'industria, 6 Cronaca; dalla F6: 7 quadro del mercato globale, 8 quadro della scalata, 9 quadro delle finanze), `target: i32` (id del treno, del deposito, della compagnia o dell'industria; ignorato per 3, 6, 7, 8 e 9). Aggiunto in F4 |
### Comandi (`Command.type`, payload in ordine)
@@ -161,6 +161,7 @@ loro fase i comandi 35–38 rispondono `NotImplemented`. Il server imposta l'emi
| 132 | Newspaper | `day: i64`, `title: string`, `articles: [(headline: string, body: string)]` |
| 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) |
Record (ognuno chiude con `flags`):
@@ -199,6 +200,8 @@ Record (ognuno chiude con `flags`):
- `GoodMarketInfo { good, available, price: f64 (centesimi), change: f32 (30 giorni), supplyMonth, demandMonth, worldSupplyMonth, worldDemandMonth, stockUnits: f64, stockMonths: f32 (−1 senza domanda), history: [PricePointInfo { day: i64, price: f64 }] (un campione per mese, l'ultimo è oggi), forecast: [ForecastInfo { months: u8, price, low, high: f64 }], sellPlaces: [SellPlaceInfo { kind: u8 (0 industria, 1 hub), target, price: f64, line: i32 (−1 non collegato) }] }`
- `TierInfo { level: u8, nameIt, nameEn: string, netWorthRequired: Money, townsRequired, townPopulation: i32, ratingRequired: string, reached: bool, reachedDay: i64 (fondazione per il livello 1; −1 se non raggiunto o sconosciuto), unlocks: [UnlockInfo] }`; `UnlockInfo { kind: u8 (0 fido, 1 squadre di cantiere, 2 compravendita in proprio, 3 acquisto di industrie, 4 quotazione, 5 scalate ostili, 6 concessioni), value: i64 (fido in centesimi o numero di squadre; 0 per gli altri) }`: gli sblocchi che il livello aggiunge al precedente
- `AmountInfo { kind: u8, value: Money }`, `LoanInfo { loan, remaining: Money, annualRate: f32, monthsLeft: i32 }`, `NetWorthPointInfo { day: i64, value: Money }`
+- `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) }`
- `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)
@@ -222,7 +225,7 @@ Record (ognuno chiude con `flags`):
`CompanyCard` (qualunque compagnia), `IndustryCard` (qualunque industria aperta) e `Chronicle`; la
Cronaca arriva da sola, una volta per sessione, quando la partita del giocatore finisce. Dalla F6
`MarketReport` (quadro del mercato globale per la compagnia della sessione), che il pannello chiede
- all'apertura e a ogni nuovo giorno; il server non lo manda da solo. Così anche `ClimbReport` (quadro della scalata), che il pannello chiede all'apertura, a ogni nuovo giorno e dopo un prestito, e la barra superiore una volta al mese.
+ all'apertura e a ogni nuovo giorno; il server non lo manda da solo. Così anche `ClimbReport` (quadro della scalata), che il pannello chiede all'apertura, a ogni nuovo giorno e dopo un prestito, e la barra superiore una volta al mese, e `FinanceReport` (quadro delle finanze), che il pannello «Finanze» chiede all'apertura, a ogni nuovo giorno e dopo un prestito o un rimborso.
- Backpressure: i moti si scartano oltre 256 KB in coda; oltre 64 MB di messaggi affidabili la
sessione si chiude (il client può riprenderla).
- Obiettivo di banda in regime: < 100 KB/s per client.
diff --git a/docs/STATE.md b/docs/STATE.md
index 207de63..4b2f368 100644
--- a/docs/STATE.md
+++ b/docs/STATE.md
@@ -129,11 +129,23 @@ Aggiornato alla fine di ogni fase (guida, sezione 18).
- protocollo: `DetailKind.Climb` (8) e `ClimbReport` (134); server: quadro su richiesta; `ClientWorld.Climb`;
- client: pannello «La tua scalata» a tutto schermo come l'immagine 08 (`ClimbPanel`: binario dei livelli con il treno e l'avanzamento, sblocchi sotto ogni livello, storico del patrimonio con i livelli segnati in `SeriesChart`, «Per diventare…» con tre barre, stato patrimoniale, conto economico, «Chiedi un prestito» e «Rimborsa»), pulsante «Scalata» nella barra degli strumenti, livello e avanzamento nella barra superiore (un clic apre il pannello), testi in `strings.csv`, schermata `17_scalata` nel pilota automatico;
- test (`Economy/ClimbTests.cs`, 7, più il quadro via WebSocket in `ServerTests`): requisiti coerenti con `Tiers.Meets` e avanzamento, sblocchi dai dati, stato patrimoniale con industria, merce, prestito e scoperto che somma al patrimonio netto, notizia di promozione con gli sblocchi, rifiuti con il livello, salvataggio versione 6 e migrazione dalla 5, proiezione e round-trip di `ClimbReport`. 170 test (152 senza i lenti).
-- Restano della F6: finanza completa, ere e obsolescenza, pannello 07, tooltip «perché», tutorial, audio, bilanciamento con i bot.
+- **Finanza completa (issue #39, ADR 0019)**:
+ - analisi delle lacune nell'ADR: prestiti, fido per livello, rate, rating mensile e bancarotta ai giorni di `difficulty.json` c'erano già; mancavano stipendi delle compagnie, finestra di 12 mesi e leva su patrimonio nel rating, misure conservate, conto economico per voce mensile e annuale, voci separate per stazioni, dazi, magazzini e dividendi incassati, avvisi prima della bancarotta, quadro nel protocollo e pannello definitivo;
+ - prestiti a tasso fisso (base della difficoltà + spread del rating all'accensione: niente spirale rating → rata → utile), rimborso anticipato parziale (stessa durata, rata più bassa) e totale senza penale, messaggi con tasso, rata, residuo e cassa disponibile;
+ - rating ogni mese da margine = utile operativo / ricavi sugli ultimi 12 mesi chiusi e leva = (prestiti + scoperto) / patrimonio netto; punteggio, misure e mesi della finestra in `Company`; margine neutro finché la finestra non è piena e ha meno di `finance.ratingMinRevenueMonths` (3) mesi con ricavi, minimo senza ricavi e in perdita; `FinanceOutlook.Explain` dice componenti, soglie con il tasso per rating, gradino sopra, margine che basta, leva massima e debito da rimborsare (se la cassa basta), oppure che il punteggio vale già il gradino sopra;
+ - voci nuove del registro: `StationUpkeep` (21), `Storage` (22), `Duties` (23), `DividendsReceived` (24, ora nell'utile); `LedgerEntries` fissa ordine e sezioni; stipendi giornalieri del personale presente nei depositi alle paghe delle industrie (`Wages`);
+ - conto economico per voce: ultimi 12 mesi chiusi e 10 anni chiusi (`finance.incomeMonths`, `incomeYears`), ogni colonna con l'utile operativo e il flusso di cassa del motore;
+ - avvisi di cassa negativa dopo `finance.negativeCashNoticeDays` (3) giorni di fila e a 30, 14, 7, 3, 1 giorni dal limite (`finance.bankruptcyWarningDaysLeft`, validati), notizia di rientro solo dopo il primo avviso, esito dell'ADR 0012 invariato; la quota dei trasporti dei nuovi concorrenti usa `Company.TransportRevenue` (tariffe, noli, contratti);
+ - salvataggio: corpo versione 7 (`FinanceSerializer`) con mesi, anni e misure del rating nell'hash; le versioni 1–6 partono senza mesi chiusi, con l'ultimo anno dal registro;
+ - protocollo: `DetailKind.Finance` (9) e `FinanceReport` (135); server: quadro su richiesta; `ClientWorld.Finance`;
+ - client: pannello «Finanze» a tutto schermo (`FinancePanel`): conto economico con «Mesi» e «Anni», rating con misure e «per salire…», soglie e tassi, prestiti con rata, interessi, scadenza, «Rimborsa» ed «Estingui», richiesta con fido e tasso, barra dei giorni di cassa negativa solo con lo scoperto; frasi intere con segnaposto in `strings.csv`; schermata `18_finanze` nel pilota automatico (non provata qui: manca l'editor);
+ - IA invariate: usano gli stessi comandi di prestito; accettazione F5 (un'IA al livello 3 in 15 anni) e F4 (35 / 20 guasti senza la linea, 75 / 2 con la linea) invariate;
+ - test (`Economy/FinanceTests.cs`, 19, più il quadro via WebSocket in `ServerTests` e il round-trip di `FinanceReport`): tasso per rating e fisso, fido dal livello e rifiuti, interessi e quota capitale sul registro, rimborso parziale e totale, rating dalle due misure e leva infinita, spiegazione che porta al gradino sopra e rimborso possibile con la cassa, punteggio che basta già (senza infiniti), margine neutro ai primi incassi, finestra di 12 mesi, conto economico che somma all'utile, stipendi dei depositi, dazi, magazzini, dividendi incassati nell'utile, avvisi e bancarotta ai giorni di ogni preset (lento), rientro e oscillazioni senza notizie, quota dei trasporti senza dividendi, salvataggio versione 7 e migrazione dalla 6, determinismo con gli invarianti, proiezione. 194 test (175 senza i lenti).
+- Restano della F6: ere e obsolescenza, pannello 07, tooltip «perché», tutorial, audio, bilanciamento con i bot.
## Prossimo passo
-- F6: finanza completa, ere e obsolescenza, pannello 07, tooltip «perché», tutorial, audio, bilanciamento con i bot su `simulate`.
+- F6: ere e obsolescenza, pannello 07, tooltip «perché», tutorial, audio, bilanciamento con i bot su `simulate`.
## Limiti noti
diff --git a/docs/adr/0019-finanza-completa.md b/docs/adr/0019-finanza-completa.md
new file mode 100644
index 0000000..331112f
--- /dev/null
+++ b/docs/adr/0019-finanza-completa.md
@@ -0,0 +1,144 @@
+# ADR 0019 — Finanza completa: prestiti per rating, conto economico per voce, bancarotta (F6)
+
+Stato: accettato (F6, issue #39).
+
+## Contesto
+
+La guida (§6.3) chiede cassa, prestiti con tasso = base + spread per rating, manutenzione, stipendi,
+interessi; rating da utile/ricavi e debito/patrimonio; bancarotta con la cassa sotto zero per i giorni
+previsti dalla difficoltà; patrimonio netto = attivo a valore di libro − debiti. Prima di scrivere codice
+si è confrontato il motore con la guida.
+
+### Analisi delle lacune
+
+C'era già, e resta com'era:
+
+- `TakeLoan` / `RepayLoan`: tasso = `baseInterestRate` della difficoltà + `ratingSpreads[rating]`
+ (`balance.json`), fissato all'accensione; fido = fido iniziale × `maxLoanFactor` del livello
+ (`tiers.json`, ADR 0011 §6); rate mensili alla francese su `loanTermMonths` con interessi e quota
+ capitale sul registro (`Interest`, `LoanRepaid`); rimborso parziale e totale limitato al residuo.
+- Rating ricalcolato ogni mese da un punteggio pesato (`profitMarginWeight`, `leverageWeight`) con le
+ soglie `ratingByScore`; D in bancarotta.
+- Bancarotta dopo `Difficulty.BankruptcyDays` giorni di fila con la cassa negativa: il numero viene da
+ `difficulty.json` (180 / 90 / 60 / 30) e si può sovrascrivere nelle impostazioni della partita; gli
+ esiti per il giocatore e per le IA sono quelli dell'ADR 0012 (`StockMarketSystem.HandleBankruptcies`,
+ `PlayerInsolvency`).
+- Patrimonio netto = attivo a valore di libro (ADR 0018) + partecipazioni + cassa − prestiti.
+- Manutenzione dei binari e della flotta sulle loro voci.
+
+Mancava o era sbagliato:
+
+1. il rating usava l'anno in corso (o l'anno chiuso nei primi mesi), non una finestra mobile, e la leva
+ era debiti / attivo invece di debiti / patrimonio; le misure non restavano da nessuna parte, quindi il
+ client non poteva spiegare il rating;
+2. le compagnie non pagavano stipendi: la voce `Wages` la usavano solo le industrie, e il personale dei
+ depositi (tecnici e operai, ADR 0009) lavorava gratis;
+3. `RunningCosts` mescolava l'esercizio dei treni con quello di stazioni e depositi; giacenze dei
+ magazzini e dazi degli hub erano dentro `Trading`; i dividendi incassati da un'altra compagnia finivano
+ su `Dividends`, la voce dei dividendi pagati, fuori dall'utile;
+4. il conto economico esisteva solo come anno in corso e ultimo anno chiuso, senza mesi né storico;
+5. nessun avviso prima della bancarotta: solo la notizia finale;
+6. nessun quadro delle finanze nel protocollo; il pannello del client mostrava cassa, patrimonio, rating
+ e un campo per chiedere un prestito;
+7. i messaggi dei prestiti erano asciutti («Cassa insufficiente») e la percentuale usava il punto.
+
+## Decisione
+
+1. **Tasso fisso.** Il tasso di un prestito resta quello dell'accensione: base della difficoltà + spread
+ del rating di quel giorno. Un tasso variabile renderebbe la rata imprevedibile e farebbe di ogni
+ declassamento una spirale (rating giù → rate su → utile giù → rating giù) proprio quando la compagnia è
+ in difficoltà; con il tasso fisso il rating decide il prezzo del debito *nuovo*, che è l'incentivo
+ che la guida chiede, e la rata mostrata al momento della richiesta resta quella. Rimborsare in anticipo
+ è sempre possibile e senza penale: chi ha migliorato il rating può estinguere e richiedere.
+ Il rimborso parziale lascia la durata invariata e ricalcola la rata.
+2. **Rating spiegabile.** Ogni mese, dopo il pagamento delle rate e la chiusura del mese:
+ - *margine* = utile operativo / ricavi sugli ultimi 12 mesi chiusi (`finance.incomeMonths`; meno se la
+ compagnia è più giovane), con i ricavi = tariffe e noli più le altre voci di ricavo solo se positive.
+ Finché la finestra non è piena e ha meno di `finance.ratingMinRevenueMonths` (3) mesi con ricavi il
+ margine è neutro (0): senza questa soglia i mesi d'avvio con soli costi davano margine 0 e il primo
+ incasso, piccolo rispetto a quei costi, faceva perdere tre o quattro gradini per un mese, proprio
+ quando un prestito nuovo avrebbe fissato lo spread peggiore per dieci anni. Con la finestra piena (o
+ con abbastanza mesi di ricavi) conta il margine vero; senza ricavi e in perdita il margine è il minimo
+ (−100 %, componente nulla);
+ - *leva* = debiti / patrimonio netto, con debiti = prestiti + scoperto di cassa; 0 senza debiti, infinita
+ con patrimonio non positivo;
+ - punteggio = `profitMarginWeight` × clamp(0,5 + margine, 0, 1) + `leverageWeight` × 1 / (1 + leva)
+ (0 con leva infinita); rating = primo gradino di `ratingByScore` non superiore al punteggio, D sotto
+ l'ultimo o in bancarotta.
+
+ Il motore conserva margine, leva, punteggio e mesi della finestra (`Company.RatingMargin`,
+ `RatingLeverage`, `RatingScore`, `RatingMonths`). `FinanceOutlook.Explain` ne ricava, senza scrivere
+ nulla, le componenti, le soglie con il tasso di un nuovo prestito per ogni rating, il gradino sopra, il
+ margine che basterebbe da solo a raggiungerlo, la leva massima e il debito da rimborsare per arrivarci
+ (a patrimonio invariato) con l'indicazione se quel rimborso è possibile oggi: si rimborsa con la cassa,
+ quindi non oltre la cassa positiva né il residuo dei prestiti, e lo scoperto non si rimborsa. Se il
+ punteggio raggiunge già il gradino sopra (rating iniziale dei dati, o D rimasto da una bancarotta
+ risolta fino al calcolo successivo) la spiegazione lo dice («vale già A, si aggiorna a inizio mese»)
+ senza obiettivi già raggiunti e senza leve infinite sul filo. Il client legge «BBB perché…, per il
+ gradino A serve…» senza calcolare nulla.
+ Prima del primo calcolo mensile (partita nuova o salvataggio migrato) il rating è quello iniziale dei
+ dati e la spiegazione usa le misure del giorno.
+3. **Voci nuove del registro.** `StationUpkeep` (21, esercizio di binari di stazione e depositi, separato
+ da `RunningCosts` che resta ai treni), `Storage` (22, giacenze dei magazzini), `Duties` (23, dazi degli
+ hub: all'importazione la quota dazio del prezzo pagato, all'esportazione l'incasso al lordo e il dazio a
+ parte, con lo stesso netto di prima), `DividendsReceived` (24, dividendi incassati da un'altra
+ compagnia). `Ledger.Transfer` accetta voci diverse per chi paga e chi incassa. Il valore numerico delle
+ voci esistenti non cambia, quindi i salvataggi restano leggibili.
+4. **Stipendi del personale dei depositi.** Ogni giorno la compagnia paga a tecnici e operai *presenti* nei
+ suoi depositi le stesse paghe delle industrie (`industry.wagePerStaffPerMonth`, `wagePerWorkerPerMonth`)
+ divise per i giorni del mese, sulla voce `Wages`. Nessun parametro nuovo: il mercato del lavoro è uno
+ solo (ADR 0009). I posti scoperti non costano.
+5. **Utile operativo.** Ricavi: noli merci, biglietti, commercio in proprio, contratti, industrie
+ possedute, controllate, dividendi incassati. Costi: esercizio dei treni, stazioni e depositi,
+ manutenzione dei treni e dei binari, stipendi, interessi, dazi, magazzini, penali. Fuori dall'utile
+ (investimenti e finanziamenti): costruzioni, acquisto e vendita di treni, acquisto di industrie,
+ prestiti ricevuti e rimborsati, azioni, dividendi pagati, altro. I dividendi incassati ora entrano
+ nell'utile (sono un reddito della compagnia), quelli pagati restano fuori. `LedgerEntries` (Core) fissa
+ ordine e sezioni; `Company.OperatingProfit` ne è la somma, usata da rating, borsa, scalata e pannello.
+ La quota dei trasporti che fa entrare un nuovo concorrente (12.1) usa invece `Company.TransportRevenue`
+ (tariffe, noli e contratti): dividendi incassati, commercio in proprio, industrie e controllate non
+ sono trasporto e non devono far sembrare una compagnia dominante.
+6. **Conto economico per voce.** A ogni chiusura di mese il registro del mese entra in
+ `Company.IncomeMonths` (ultimi `finance.incomeMonths` = 12), a ogni chiusura d'anno quello dell'anno in
+ `Company.IncomeYears` (ultimi `finance.incomeYears` = 10). Il quadro (`FinanceOutlook`) mostra il mese in
+ corso, i mesi chiusi, l'anno in corso e gli anni chiusi, ogni colonna con l'utile operativo e il flusso
+ di cassa del motore: le righe sommano al centesimo all'utile perché sono le stesse voci del registro.
+7. **Avvisi di bancarotta.** Dopo `finance.negativeCashNoticeDays` (3) giorni di fila di cassa negativa
+ una notizia (avviso) dice lo scoperto e i giorni al limite della difficoltà; poi una notizia a 30, 14,
+ 7, 3 e 1 giorno dal limite (`finance.bankruptcyWarningDaysLeft`, l'ultima critica); se la cassa torna
+ positiva dopo almeno quei giorni una notizia dice che il conto alla rovescia si azzera; al limite la
+ notizia della bancarotta. Una cassa che oscilla intorno a zero (costi giornalieri contro incassi) azzera
+ il conto ogni volta senza riempire le notizie. Il pannello mostra il conto alla rovescia solo con la
+ cassa davvero negativa: dopo un prestito che la riporta sopra zero dice che il conto si azzera domani
+ (il motore conta i giorni una volta al giorno). L'esito resta quello dell'ADR 0012.
+8. **Salvataggio versione 7.** `FinanceSerializer` in coda allo stato dinamico, nell'hash: mesi e anni
+ chiusi (voci allungate a zero se in futuro se ne aggiungono) e misure del rating. Le versioni 1–6 si
+ caricano con zero mesi chiusi (la finestra si riempie dal mese dopo), l'ultimo anno chiuso ricavato dal
+ registro come primo anno dello storico e `RatingMonths` = 0; il rating salvato resta.
+9. **Protocollo e client.** `DetailKind.Finance` (9) e `FinanceReport` (135) su richiesta; il pannello
+ «Finanze» diventa a tutto schermo: conto economico per voce con «Mesi» (mese in corso, cinque mesi
+ chiusi, anno in corso) e «Anni» (anno in corso, cinque anni chiusi), rating con misure, componenti,
+ soglie e «per salire…», prestiti con rata, interessi, scadenza, «Rimborsa» ed «Estingui», richiesta con
+ il fido e il tasso, barra rossa dei giorni di cassa negativa sul limite.
+10. **Messaggi.** Accensione: «Prestito di X al 6,0% fisso (base … + rating BB …) per 10 anni: rata mensile
+ Y»; rimborso: «Rimborsati X: restano R, nuova rata mensile P» o «… prestito estinto»; rifiuto: «Cassa
+ insufficiente: per rimborsare X ci sono Y in cassa». Percentuali con la virgola.
+
+## Conseguenze
+
+- Le compagnie con depositi pagano gli stipendi e hanno utili un po' più bassi; il rating guarda fino a
+ 12 mesi e la leva sul patrimonio. Nei primi mesi il margine non conta finché non ci sono tre mesi con
+ ricavi, quindi all'avvio il rating dipende dalla leva; da lì in poi la finestra cresce mese per mese e il
+ rating si muove più dei mesi successivi, quando la finestra è piena. Le IA usano gli
+ stessi prestiti e lo stesso rating (nessun cambiamento nel loro codice); le soglie restano provvisorie
+ fino al bilanciamento della F6.
+- Il salvataggio cresce di circa 22 mesi × 25 voci per compagnia; l'hash giornaliero li include.
+- Il quadro delle finanze si calcola solo su richiesta.
+
+## Limiti
+
+- Niente ammortamento a conto economico: il valore di libro scende (ADR 0018) ma la perdita di valore non
+ è una voce dell'utile. Niente imposte.
+- Il tasso non dipende dalla durata e la durata è una sola (`loanTermMonths`).
+- I mesi chiusi prima della versione 7 non si recuperano: dopo una migrazione il rating usa la finestra
+ dal primo mese chiuso dopo il caricamento.
diff --git a/src/RailEnterprise.Core/Data/BalanceDefs.cs b/src/RailEnterprise.Core/Data/BalanceDefs.cs
index cacf582..ce335a1 100644
--- a/src/RailEnterprise.Core/Data/BalanceDefs.cs
+++ b/src/RailEnterprise.Core/Data/BalanceDefs.cs
@@ -390,6 +390,25 @@ public sealed class FinanceBalance
public required CreditRating StartingRating { get; init; }
public required int DepreciationYearsTrack { get; init; }
public required double BookValueFloor { get; init; }
+ /// Mesi chiusi conservati per voce: conto economico mensile e finestra del rating (ADR 0019).
+ public required int IncomeMonths { get; init; }
+ /// Anni chiusi conservati per voce nel conto economico annuale (ADR 0019).
+ public required int IncomeYears { get; init; }
+ ///
+ /// Giorni mancanti alla bancarotta in cui la compagnia riceve un avviso, in ordine decrescente
+ /// (oltre al primo avviso dopo giorni, ADR 0019).
+ ///
+ public required int[] BankruptcyWarningDaysLeft { get; init; }
+ ///
+ /// Mesi chiusi con ricavi che servono, finché la finestra del rating non è piena, perché il margine
+ /// conti: prima il margine è neutro (0), così i primi incassi non fanno crollare il rating (ADR 0019).
+ ///
+ public required int RatingMinRevenueMonths { get; init; }
+ ///
+ /// Giorni di cassa negativa di fila prima del primo avviso; il rientro si annuncia solo dopo almeno
+ /// altrettanti giorni, così una cassa che oscilla intorno a zero non riempie le notizie (ADR 0019).
+ ///
+ public required int NegativeCashNoticeDays { get; init; }
}
public sealed class StockMarketBalance
diff --git a/src/RailEnterprise.Core/Data/DataValidator.cs b/src/RailEnterprise.Core/Data/DataValidator.cs
index ed9c6a9..7ad1af0 100644
--- a/src/RailEnterprise.Core/Data/DataValidator.cs
+++ b/src/RailEnterprise.Core/Data/DataValidator.cs
@@ -190,6 +190,18 @@ public static class DataValidator
RequireKeys("balance.json", "finance.ratingSpreads", b.Finance.RatingSpreads.Keys, Enum.GetNames(), errors);
if (b.Finance.RatingByScore.Length != 9) Err("balance.json", "finance.ratingByScore deve avere 9 soglie (AAA … C)");
Increasing("balance.json", "finance.ratingByScore (decrescente)", Enumerable.Reverse(b.Finance.RatingByScore), errors);
+ if (b.Finance.IncomeMonths < 1 || b.Finance.IncomeMonths > 120) Err("balance.json", "finance.incomeMonths deve stare tra 1 e 120");
+ if (b.Finance.IncomeYears < 1 || b.Finance.IncomeYears > 100) Err("balance.json", "finance.incomeYears deve stare tra 1 e 100");
+ if (b.Finance.RatingMinRevenueMonths < 1 || b.Finance.RatingMinRevenueMonths > b.Finance.IncomeMonths)
+ Err("balance.json", "finance.ratingMinRevenueMonths deve stare tra 1 e finance.incomeMonths");
+ if (b.Finance.NegativeCashNoticeDays < 1) Err("balance.json", "finance.negativeCashNoticeDays deve essere almeno 1");
+ if (b.Finance.ProfitMarginWeight <= 0 || b.Finance.LeverageWeight <= 0) Err("balance.json", "finance.profitMarginWeight e finance.leverageWeight devono essere positivi");
+ for (int i = 0; i < b.Finance.BankruptcyWarningDaysLeft.Length; i++)
+ {
+ if (b.Finance.BankruptcyWarningDaysLeft[i] < 1) Err("balance.json", "finance.bankruptcyWarningDaysLeft: i giorni devono essere almeno 1");
+ if (i > 0 && b.Finance.BankruptcyWarningDaysLeft[i] >= b.Finance.BankruptcyWarningDaysLeft[i - 1])
+ Err("balance.json", "finance.bankruptcyWarningDaysLeft deve essere strettamente decrescente");
+ }
RequireKeys("balance.json", "industryMaintenance.budgets", b.IndustryMaintenance.Budgets.Keys, ["none", "base", "high"], errors);
if (b.IndustryMaintenance.BreakdownDays.Length != 2) Err("balance.json", "industryMaintenance.breakdownDays deve essere [min, max]");
if (b.Growth.MaxLevel > 5 || b.Growth.MaxLevel < 1) Err("balance.json", "growth.maxLevel deve stare tra 1 e 5");
diff --git a/src/RailEnterprise.Core/Economy/ClimbOutlook.cs b/src/RailEnterprise.Core/Economy/ClimbOutlook.cs
index daad38d..3dbd250 100644
--- a/src/RailEnterprise.Core/Economy/ClimbOutlook.cs
+++ b/src/RailEnterprise.Core/Economy/ClimbOutlook.cs
@@ -74,9 +74,9 @@ public enum IncomeLineKind : byte
{
/// Tariffe passeggeri e noli merci.
Fares = 0,
- /// Commercio in proprio, contratti, industrie possedute, controllate.
+ /// Commercio in proprio, contratti, industrie possedute, controllate, dividendi incassati.
OtherIncome = 1,
- /// Costi d'esercizio, salari, penali.
+ /// Costi d'esercizio (treni, stazioni e depositi), salari, penali, dazi, magazzini.
OperatingCosts = 2,
/// Manutenzione dei binari e della flotta.
Maintenance = 3,
@@ -119,7 +119,7 @@ public sealed class ClimbOutlookReport
public required Money MaxLoan { get; init; }
public required Money LoanAvailable { get; init; }
public required double NewLoanRate { get; init; }
- /// In amministrazione controllata i prestiti non si possono chiedere.
+ /// In bancarotta o in amministrazione controllata i prestiti non si possono chiedere (come in ).
public required bool LoansAllowed { get; init; }
/// Patrimonio netto: fondazione, fine di ogni anno dello storico, oggi.
public required List History { get; init; }
@@ -165,7 +165,7 @@ public static class ClimbOutlook
MaxLoan = max,
LoanAvailable = Money.Max(Money.Zero, max - c.Debt),
NewLoanRate = FinanceSystem.LoanRate(w, c),
- LoansAllowed = !c.Receivership,
+ LoansAllowed = !c.Receivership && !c.Bankrupt,
History = History(w, c),
};
}
@@ -258,8 +258,10 @@ public static class ClimbOutlook
var lines = new List
{
new(IncomeLineKind.Fares, new Money(Sum(LedgerEntry.FreightRevenue, LedgerEntry.PassengerRevenue))),
- new(IncomeLineKind.OtherIncome, new Money(Sum(LedgerEntry.Trading, LedgerEntry.Contracts, LedgerEntry.Industries, LedgerEntry.Subsidiaries))),
- new(IncomeLineKind.OperatingCosts, new Money(Sum(LedgerEntry.RunningCosts, LedgerEntry.Wages, LedgerEntry.Penalties))),
+ new(IncomeLineKind.OtherIncome, new Money(Sum(LedgerEntry.Trading, LedgerEntry.Contracts, LedgerEntry.Industries, LedgerEntry.Subsidiaries,
+ LedgerEntry.DividendsReceived))),
+ new(IncomeLineKind.OperatingCosts, new Money(Sum(LedgerEntry.RunningCosts, LedgerEntry.StationUpkeep, LedgerEntry.Wages, LedgerEntry.Penalties,
+ LedgerEntry.Duties, LedgerEntry.Storage))),
new(IncomeLineKind.Maintenance, new Money(Sum(LedgerEntry.TrackMaintenance, LedgerEntry.FleetMaintenance))),
new(IncomeLineKind.Interest, new Money(Sum(LedgerEntry.Interest))),
};
diff --git a/src/RailEnterprise.Core/Economy/Company.cs b/src/RailEnterprise.Core/Economy/Company.cs
index d9d145f..8679a5c 100644
--- a/src/RailEnterprise.Core/Economy/Company.cs
+++ b/src/RailEnterprise.Core/Economy/Company.cs
@@ -29,6 +29,66 @@ public enum LedgerEntry : byte
Industries = 19,
/// Utili versati dalle compagnie controllate.
Subsidiaries = 20,
+ /// Esercizio dei binari di stazione e dei depositi (prima dentro , ADR 0019).
+ StationUpkeep = 21,
+ /// Giacenza della merce nei magazzini della compagnia (prima dentro , ADR 0019).
+ Storage = 22,
+ /// Dazi sugli scambi in proprio con gli hub (prima dentro , ADR 0019).
+ Duties = 23,
+ /// Dividendi incassati dalle azioni di altre compagnie (ADR 0019); resta per quelli pagati.
+ DividendsReceived = 24,
+}
+
+/// Sezione del conto economico di una voce del registro (ADR 0019).
+public enum IncomeSection : byte
+{
+ /// Ricavi d'esercizio: entrano nell'utile operativo.
+ Revenue = 0,
+ /// Costi d'esercizio: entrano nell'utile operativo.
+ Cost = 1,
+ /// Investimenti e finanziamenti: muovono la cassa ma non l'utile operativo.
+ Capital = 2,
+}
+
+///
+/// Classificazione delle voci del registro (ADR 0019): unica fonte dell'utile operativo, dei ricavi del
+/// rating e delle righe del conto economico del pannello delle finanze.
+///
+public static class LedgerEntries
+{
+ /// Voci nell'ordine del conto economico: ricavi, costi, investimenti e finanziamenti.
+ public static readonly LedgerEntry[] Ordered =
+ [
+ LedgerEntry.FreightRevenue, LedgerEntry.PassengerRevenue, LedgerEntry.Trading, LedgerEntry.Contracts,
+ LedgerEntry.Industries, LedgerEntry.Subsidiaries, LedgerEntry.DividendsReceived,
+ LedgerEntry.RunningCosts, LedgerEntry.StationUpkeep, LedgerEntry.FleetMaintenance, LedgerEntry.TrackMaintenance,
+ LedgerEntry.Wages, LedgerEntry.Interest, LedgerEntry.Duties, LedgerEntry.Storage, LedgerEntry.Penalties,
+ LedgerEntry.Construction, LedgerEntry.VehiclePurchase, LedgerEntry.VehicleSale, LedgerEntry.IndustryPurchase,
+ LedgerEntry.LoanTaken, LedgerEntry.LoanRepaid, LedgerEntry.Shares, LedgerEntry.Dividends, LedgerEntry.Other,
+ ];
+
+ public static IncomeSection Section(LedgerEntry e) => e switch
+ {
+ LedgerEntry.FreightRevenue or LedgerEntry.PassengerRevenue or LedgerEntry.Trading or LedgerEntry.Contracts
+ or LedgerEntry.Industries or LedgerEntry.Subsidiaries or LedgerEntry.DividendsReceived => IncomeSection.Revenue,
+ LedgerEntry.RunningCosts or LedgerEntry.StationUpkeep or LedgerEntry.FleetMaintenance or LedgerEntry.TrackMaintenance
+ or LedgerEntry.Wages or LedgerEntry.Interest or LedgerEntry.Duties or LedgerEntry.Storage or LedgerEntry.Penalties => IncomeSection.Cost,
+ _ => IncomeSection.Capital,
+ };
+
+ /// Vero per le voci che entrano nell'utile operativo (ricavi e costi d'esercizio).
+ public static bool Operating(LedgerEntry e) => Section(e) != IncomeSection.Capital;
+}
+
+///
+/// Movimenti per voce di un mese o di un anno chiuso (ADR 0019): 1–12 per un mese,
+/// 0 per un anno intero.
+///
+public sealed class IncomeRecord
+{
+ public required int Year { get; init; }
+ public required int Month { get; init; }
+ public required long[] Entries { get; init; }
}
/// Voci dello stato patrimoniale per gli attivi non monetari (ADR 0018).
@@ -65,7 +125,7 @@ public sealed class Loan
/// Compagnia ferroviaria (giocatore o IA).
public sealed class Company
{
- public const int EntryCount = 21;
+ public const int EntryCount = 25;
public required CompanyId Id { get; init; }
public required string Name { get; set; }
@@ -97,6 +157,22 @@ public sealed class Company
/// Movimenti dell'anno precedente per voce (per rating e borsa).
public long[] LastYearEntries { get; } = new long[EntryCount];
+ /// Mesi chiusi per voce, dal più vecchio (al massimo finance.incomeMonths, ADR 0019).
+ public List IncomeMonths { get; } = [];
+
+ /// Anni chiusi per voce, dal più vecchio (al massimo finance.incomeYears, ADR 0019).
+ public List IncomeYears { get; } = [];
+
+ ///
+ /// Misure dell'ultimo calcolo del rating (ADR 0019): margine = utile operativo / ricavi dei mesi della
+ /// finestra, leva = debiti / patrimonio netto (+∞ con patrimonio non positivo e debiti), punteggio
+ /// pesato e numero di mesi della finestra (0 prima del primo calcolo).
+ ///
+ public double RatingMargin { get; set; }
+ public double RatingLeverage { get; set; }
+ public double RatingScore { get; set; }
+ public int RatingMonths { get; set; }
+
///
/// Valore contabile degli attivi non monetari per voce (, centesimi),
/// aggiornato ogni mese da FinanceSystem.UpdateBookValues (ADR 0018).
@@ -204,20 +280,41 @@ public sealed class Company
/// Capitalizzazione di borsa (centesimi).
public double MarketCap => SharePrice * Shares.Outstanding;
- /// Utile operativo dell'anno indicato (ricavi meno costi d'esercizio, esclusi prestiti e investimenti).
+ ///
+ /// Utile operativo dei movimenti indicati: somma delle voci di ricavo e di costo d'esercizio
+ /// (), esclusi prestiti, investimenti e capitale.
+ ///
public static long OperatingProfit(long[] entries)
{
- long revenue = entries[(int)LedgerEntry.FreightRevenue] + entries[(int)LedgerEntry.PassengerRevenue]
- + entries[(int)LedgerEntry.Trading] + entries[(int)LedgerEntry.Contracts]
- + entries[(int)LedgerEntry.Industries] + entries[(int)LedgerEntry.Subsidiaries];
- long costs = entries[(int)LedgerEntry.RunningCosts] + entries[(int)LedgerEntry.TrackMaintenance]
- + entries[(int)LedgerEntry.FleetMaintenance] + entries[(int)LedgerEntry.Wages]
- + entries[(int)LedgerEntry.Interest] + entries[(int)LedgerEntry.Penalties];
- return revenue + costs; // i costi sono già negativi
+ long sum = 0;
+ for (int i = 0; i < entries.Length && i < EntryCount; i++)
+ {
+ if (LedgerEntries.Operating((LedgerEntry)i)) sum += entries[i]; // i costi sono già negativi
+ }
+ return sum;
}
- public static long Revenue(long[] entries) =>
- entries[(int)LedgerEntry.FreightRevenue] + entries[(int)LedgerEntry.PassengerRevenue]
- + Math.Max(0, entries[(int)LedgerEntry.Trading]) + Math.Max(0, entries[(int)LedgerEntry.Contracts])
- + Math.Max(0, entries[(int)LedgerEntry.Industries]) + Math.Max(0, entries[(int)LedgerEntry.Subsidiaries]);
+ ///
+ /// Ricavi dei trasporti: tariffe merci e passeggeri e contratti con le industrie (se positivi). Misura la
+ /// quota dei trasporti dei nuovi concorrenti (12.1), senza commercio in proprio, industrie, controllate
+ /// e dividendi incassati, che non sono trasporto.
+ ///
+ public static long TransportRevenue(long[] entries) =>
+ entries[(int)LedgerEntry.FreightRevenue] + entries[(int)LedgerEntry.PassengerRevenue] + Math.Max(0, entries[(int)LedgerEntry.Contracts]);
+
+ ///
+ /// Ricavi d'esercizio: tariffe merci e passeggeri come sono, le altre voci di ricavo solo se positive
+ /// (commercio, contratti, industrie, controllate, dividendi incassati).
+ ///
+ public static long Revenue(long[] entries)
+ {
+ long sum = entries[(int)LedgerEntry.FreightRevenue] + entries[(int)LedgerEntry.PassengerRevenue];
+ for (int i = 0; i < entries.Length && i < EntryCount; i++)
+ {
+ var e = (LedgerEntry)i;
+ if (e is LedgerEntry.FreightRevenue or LedgerEntry.PassengerRevenue || LedgerEntries.Section(e) != IncomeSection.Revenue) continue;
+ sum += Math.Max(0, entries[i]);
+ }
+ return sum;
+ }
}
diff --git a/src/RailEnterprise.Core/Economy/FinanceOutlook.cs b/src/RailEnterprise.Core/Economy/FinanceOutlook.cs
new file mode 100644
index 0000000..98dab44
--- /dev/null
+++ b/src/RailEnterprise.Core/Economy/FinanceOutlook.cs
@@ -0,0 +1,287 @@
+using System.Globalization;
+using RailEnterprise.Core.Common;
+using RailEnterprise.Core.Data;
+using RailEnterprise.Core.Simulation;
+using RailEnterprise.Core.Simulation.Systems;
+
+namespace RailEnterprise.Core.Economy;
+
+/// Colonna del conto economico: mese in corso, mese chiuso, anno in corso o anno chiuso.
+public enum IncomeColumnKind : byte
+{
+ CurrentMonth = 0,
+ Month = 1,
+ CurrentYear = 2,
+ Year = 3,
+}
+
+///
+/// Movimenti per voce di un periodo ( valori, indice = ),
+/// con l'utile operativo del motore e il flusso di cassa (somma di tutte le voci).
+///
+public sealed class IncomeColumn
+{
+ public required IncomeColumnKind Kind { get; init; }
+ public required int Year { get; init; }
+ /// Mese 1–12 per le colonne mensili, 0 per quelle annuali.
+ public required int Month { get; init; }
+ public required long[] Entries { get; init; }
+ /// Utile operativo: sulle stesse voci.
+ public required Money Profit { get; init; }
+ /// Variazione della cassa nel periodo: somma di tutte le voci, investimenti e finanziamenti compresi.
+ public required Money CashFlow { get; init; }
+}
+
+/// Soglia di un rating: punteggio minimo e tasso di un nuovo prestito con quel rating.
+public readonly record struct RatingThreshold(CreditRating Rating, double MinScore, double LoanRate);
+
+///
+/// Spiegazione del rating (ADR 0019): le due misure conservate dal motore all'ultimo calcolo, le
+/// componenti e il punteggio, le soglie, e cosa servirebbe per il gradino sopra.
+///
+public sealed class RatingExplanation
+{
+ public required CreditRating Rating { get; init; }
+ /// Vero prima del primo calcolo mensile: il rating è quello iniziale dei dati e le misure sono di oggi.
+ public required bool Initial { get; init; }
+ public required bool Bankrupt { get; init; }
+ /// Mesi chiusi nella finestra del margine (fino a finance.incomeMonths).
+ public required int Months { get; init; }
+ /// Mesi della finestra con ricavi.
+ public required int RevenueMonths { get; init; }
+ ///
+ /// Margine neutro (0) perché la finestra non è piena e ha meno di mesi
+ /// con ricavi (avvio della compagnia).
+ ///
+ public required bool MarginNeutral { get; init; }
+ /// Mesi con ricavi che servono perché il margine conti prima che la finestra sia piena (finance.ratingMinRevenueMonths).
+ public required int MinRevenueMonths { get; init; }
+ public required double Margin { get; init; }
+ /// Debiti / patrimonio netto (+∞ con patrimonio non positivo e debiti: ).
+ public required double Leverage { get; init; }
+ public bool LeverageUnbounded => double.IsPositiveInfinity(Leverage);
+ public required double MarginWeight { get; init; }
+ public required double LeverageWeight { get; init; }
+ public required double MarginComponent { get; init; }
+ public required double LeverageComponent { get; init; }
+ public required double Score { get; init; }
+ /// Soglie da AAA a C (sotto l'ultima è D).
+ public required List Thresholds { get; init; }
+ /// Gradino sopra (null ad AAA) e punteggio che richiede.
+ public required CreditRating? Next { get; init; }
+ public required double NextThreshold { get; init; }
+ /// Rating che corrisponde al punteggio (D in bancarotta).
+ public required CreditRating ScoreRating { get; init; }
+ ///
+ /// Il punteggio raggiunge già il gradino sopra: il rating mostrato è quello iniziale o di un calcolo
+ /// precedente e cambia al prossimo calcolo mensile. Margine e leva necessari non si calcolano.
+ ///
+ public required bool NextAlreadyMet { get; init; }
+ /// Margine che basterebbe da solo, a leva invariata (se raggiungibile).
+ public required double MarginNeeded { get; init; }
+ public required bool MarginReachable { get; init; }
+ /// Debiti/patrimonio massimo che basterebbe da solo, a margine invariato (se raggiungibile).
+ public required double LeverageMax { get; init; }
+ public required bool LeverageReachable { get; init; }
+ /// Debiti da rimborsare oggi per scendere sotto (0 se già sotto o irraggiungibile).
+ public required Money DebtToRepay { get; init; }
+ ///
+ /// Il rimborso di si può fare oggi: non supera la cassa disponibile né il
+ /// residuo dei prestiti (lo scoperto non si rimborsa, si copre solo riportando la cassa sopra zero).
+ ///
+ public required bool RepayAffordable { get; init; }
+}
+
+/// Prestito in corso con rata e scadenza.
+public sealed class LoanDetail
+{
+ public required LoanId Id { get; init; }
+ public required Money Principal { get; init; }
+ public required Money Remaining { get; init; }
+ /// Tasso annuo fissato all'accensione.
+ public required double AnnualRate { get; init; }
+ public required int MonthsLeft { get; init; }
+ /// Rata mensile costante sul residuo e i mesi restanti (alla francese).
+ public required Money Payment { get; init; }
+ /// Interessi della prossima rata.
+ public required Money NextInterest { get; init; }
+ /// Giorno dell'ultima rata (primo giorno del mese).
+ public required long MaturityDay { get; init; }
+}
+
+public sealed class FinanceOutlookReport
+{
+ public required long Day { get; init; }
+ public required CompanyId Company { get; init; }
+ public required Money Cash { get; init; }
+ public required Money NetWorth { get; init; }
+ /// Residuo dei prestiti.
+ public required Money Loans { get; init; }
+ /// Cassa negativa (scoperto), tra i debiti del rating.
+ public required Money Overdraft { get; init; }
+ /// Voci del conto economico nell'ordine di presentazione, con la loro sezione.
+ public required List<(LedgerEntry Entry, IncomeSection Section)> Lines { get; init; }
+ /// Mese in corso, mesi chiusi dal più recente, anno in corso, anni chiusi dal più recente.
+ public required List Columns { get; init; }
+ public required RatingExplanation Rating { get; init; }
+ public required List LoanList { get; init; }
+ public required Money MaxLoan { get; init; }
+ public required Money LoanAvailable { get; init; }
+ /// Tasso di un nuovo prestito: base della difficoltà + spread del rating.
+ public required double NewLoanRate { get; init; }
+ public required double BaseRate { get; init; }
+ public required double Spread { get; init; }
+ public required int LoanTermMonths { get; init; }
+ public required Money LoanStep { get; init; }
+ public required bool LoansAllowed { get; init; }
+ public required int NegativeCashDays { get; init; }
+ /// Giorni di cassa negativa che portano alla bancarotta (difficulty.json, bankruptcyDays).
+ public required int BankruptcyDays { get; init; }
+ public required bool Bankrupt { get; init; }
+ public required bool Receivership { get; init; }
+}
+
+///
+/// Quadro delle finanze per il pannello «Finanze» (ADR 0019): pura funzione del mondo, come
+/// . Conto economico per voce (mese in corso, mesi chiusi, anno in corso, anni
+/// chiusi) dalle stesse voci del registro che danno l'utile operativo, prestiti con rata e scadenza,
+/// spiegazione del rating dalle misure conservate dal motore, conto alla rovescia della bancarotta.
+///
+public static class FinanceOutlook
+{
+ public static FinanceOutlookReport Build(World w, CompanyId company)
+ {
+ var c = w.Company(company);
+ var fb = w.Data.Balance.Finance;
+ var max = FinanceSystem.MaxLoan(w, c);
+ return new FinanceOutlookReport
+ {
+ Day = w.Clock.Day,
+ Company = c.Id,
+ Cash = c.Cash,
+ NetWorth = c.NetWorth,
+ Loans = c.Debt,
+ Overdraft = Money.Max(Money.Zero, -c.Cash),
+ Lines = LedgerEntries.Ordered.Select(e => (e, LedgerEntries.Section(e))).ToList(),
+ Columns = Columns(w, c),
+ Rating = Explain(w, c),
+ LoanList = c.Loans.Select(l => Detail(w, l)).ToList(),
+ MaxLoan = max,
+ LoanAvailable = Money.Max(Money.Zero, max - c.Debt),
+ NewLoanRate = FinanceSystem.LoanRate(w, c),
+ BaseRate = w.Difficulty.BaseInterestRate,
+ Spread = fb.RatingSpreads[c.Rating.ToString()],
+ LoanTermMonths = fb.LoanTermMonths,
+ LoanStep = new Money(fb.LoanStep),
+ LoansAllowed = !c.Receivership && !c.Bankrupt,
+ NegativeCashDays = c.NegativeCashDays,
+ BankruptcyDays = w.Difficulty.BankruptcyDays,
+ Bankrupt = c.Bankrupt,
+ Receivership = c.Receivership,
+ };
+ }
+
+ /// Colonne del conto economico: mese in corso, mesi chiusi (dal più recente), anno in corso, anni chiusi.
+ public static List Columns(World w, Company c)
+ {
+ var today = w.Calendar.DateOfDay(w.Clock.Day);
+ var list = new List { Column(IncomeColumnKind.CurrentMonth, today.Year, today.Month, c.MonthEntries) };
+ for (int i = c.IncomeMonths.Count - 1; i >= 0; i--)
+ list.Add(Column(IncomeColumnKind.Month, c.IncomeMonths[i].Year, c.IncomeMonths[i].Month, c.IncomeMonths[i].Entries));
+ list.Add(Column(IncomeColumnKind.CurrentYear, today.Year, 0, c.YearEntries));
+ for (int i = c.IncomeYears.Count - 1; i >= 0; i--)
+ list.Add(Column(IncomeColumnKind.Year, c.IncomeYears[i].Year, 0, c.IncomeYears[i].Entries));
+ return list;
+ }
+
+ private static IncomeColumn Column(IncomeColumnKind kind, int year, int month, long[] source)
+ {
+ var entries = new long[Company.EntryCount];
+ Array.Copy(source, entries, Math.Min(source.Length, entries.Length));
+ long flow = 0;
+ foreach (long v in entries) flow += v;
+ return new IncomeColumn
+ {
+ Kind = kind, Year = year, Month = month, Entries = entries,
+ Profit = new Money(Company.OperatingProfit(entries)), CashFlow = new Money(flow),
+ };
+ }
+
+ /// Prestito con la rata sul residuo e la scadenza al primo giorno del mese dell'ultima rata.
+ public static LoanDetail Detail(World w, Loan l)
+ {
+ int dpm = w.Calendar.DaysPerMonth;
+ long monthStart = w.Clock.Day / dpm * dpm;
+ return new LoanDetail
+ {
+ Id = l.Id, Principal = l.Principal, Remaining = l.Remaining, AnnualRate = l.AnnualRate, MonthsLeft = l.MonthsLeft,
+ Payment = FinanceSystem.MonthlyPayment(l.Remaining, l.AnnualRate, l.MonthsLeft),
+ NextInterest = Money.FromCentsRounded(l.Remaining.Cents * l.AnnualRate / 12),
+ MaturityDay = monthStart + (long)Math.Max(0, l.MonthsLeft) * dpm,
+ };
+ }
+
+ ///
+ /// Spiegazione del rating con le misure dell'ultimo calcolo mensile (prima del primo calcolo, quelle di
+ /// oggi). Per il gradino sopra: il margine che basterebbe a leva invariata, il debiti/patrimonio massimo
+ /// a margine invariato e quanto debito rimborsare oggi per arrivarci (a patrimonio invariato: il
+ /// rimborso toglie lo stesso importo da cassa e debiti). Se il punteggio raggiunge già il gradino sopra
+ /// (rating iniziale o rimasto da un calcolo precedente) lo dice e non calcola obiettivi già raggiunti.
+ ///
+ public static RatingExplanation Explain(World w, Company c)
+ {
+ var fb = w.Data.Balance.Finance;
+ bool initial = c.RatingMonths == 0;
+ var live = FinanceSystem.Measures(w, c);
+ double margin = initial ? live.Margin : c.RatingMargin;
+ double leverage = initial ? live.Leverage : c.RatingLeverage;
+ double cm = FinanceSystem.MarginComponent(margin), cl = FinanceSystem.LeverageComponent(leverage);
+ double score = fb.ProfitMarginWeight * cm + fb.LeverageWeight * cl;
+ var thresholds = new List(fb.RatingByScore.Length);
+ for (int i = 0; i < fb.RatingByScore.Length; i++)
+ thresholds.Add(new RatingThreshold((CreditRating)i, fb.RatingByScore[i], FinanceSystem.LoanRate(w, (CreditRating)i)));
+
+ CreditRating? next = c.Rating > CreditRating.AAA ? c.Rating - 1 : null;
+ double target = next is { } n ? fb.RatingByScore[(int)n] : 0;
+ var scoreRating = c.Bankrupt ? CreditRating.D : FinanceSystem.RatingOf(w, score);
+ bool alreadyMet = next is not null && !c.Bankrupt && score >= target;
+ double marginNeeded = 0, leverageMax = 0;
+ bool marginOk = false, leverageOk = false, affordable = false;
+ var repay = Money.Zero;
+ if (next is not null && !c.Bankrupt && !alreadyMet)
+ {
+ // punteggio sotto la soglia: needCm > cm ≥ 0 e needCl > cl ≥ 0, quindi niente infiniti
+ // pesoMargine·clamp(0,5 + m) + pesoLeva·cl = soglia → m
+ double needCm = (target - fb.LeverageWeight * cl) / fb.ProfitMarginWeight;
+ marginOk = needCm <= 1;
+ marginNeeded = needCm - 0.5;
+ // pesoMargine·cm + pesoLeva / (1 + ℓ) = soglia → ℓ
+ double needCl = (target - fb.ProfitMarginWeight * cm) / fb.LeverageWeight;
+ leverageOk = needCl <= 1;
+ leverageMax = leverageOk ? 1 / needCl - 1 : 0;
+ if (leverageOk && live.Equity > 0)
+ {
+ repay = new Money(Math.Max(0, live.Debt - (long)Math.Floor(leverageMax * live.Equity)));
+ // si rimborsano i prestiti con la cassa: non oltre la cassa positiva né oltre il residuo
+ long repayable = Math.Min(c.Debt.Cents, Math.Max(0, c.Cash.Cents));
+ affordable = repay.Cents <= repayable;
+ }
+ }
+ return new RatingExplanation
+ {
+ Rating = c.Rating, Initial = initial, Bankrupt = c.Bankrupt,
+ Months = initial ? live.Months : c.RatingMonths,
+ RevenueMonths = live.RevenueMonths, MarginNeutral = live.MarginNeutral, MinRevenueMonths = fb.RatingMinRevenueMonths,
+ Margin = margin, Leverage = leverage,
+ MarginWeight = fb.ProfitMarginWeight, LeverageWeight = fb.LeverageWeight,
+ MarginComponent = cm, LeverageComponent = cl, Score = score,
+ Thresholds = thresholds, Next = next, NextThreshold = target, ScoreRating = scoreRating, NextAlreadyMet = alreadyMet,
+ MarginNeeded = marginNeeded, MarginReachable = marginOk,
+ LeverageMax = leverageMax, LeverageReachable = leverageOk, DebtToRepay = repay, RepayAffordable = affordable,
+ };
+ }
+
+ /// Tasso in percentuale all'italiana con un decimale («6,5%»).
+ public static string Percent(double rate) =>
+ (rate * 100).ToString("0.0", CultureInfo.InvariantCulture).Replace('.', ',') + "%";
+}
diff --git a/src/RailEnterprise.Core/Economy/Ledger.cs b/src/RailEnterprise.Core/Economy/Ledger.cs
index 2b1348d..cbac5d8 100644
--- a/src/RailEnterprise.Core/Economy/Ledger.cs
+++ b/src/RailEnterprise.Core/Economy/Ledger.cs
@@ -26,11 +26,17 @@ public sealed class MoneyLedger(Func companies, FuncTotale trasferito dall'inizio (statistica).
public long TransfersCount { get; internal set; }
- public void Transfer(Account from, Account to, Money amount, LedgerEntry entry)
+ public void Transfer(Account from, Account to, Money amount, LedgerEntry entry) => Transfer(from, to, amount, entry, entry);
+
+ ///
+ /// Trasferimento registrato su voci diverse per chi paga e chi incassa (per esempio dividendi pagati
+ /// e dividendi incassati, ADR 0019): la somma dei saldi resta zero.
+ ///
+ public void Transfer(Account from, Account to, Money amount, LedgerEntry fromEntry, LedgerEntry toEntry)
{
if (amount.Cents == 0 || from == to) return;
- Adjust(from, -amount, entry);
- Adjust(to, amount, entry);
+ Adjust(from, -amount, fromEntry);
+ Adjust(to, amount, toEntry);
TransfersCount++;
}
diff --git a/src/RailEnterprise.Core/Persistence/FinanceSerializer.cs b/src/RailEnterprise.Core/Persistence/FinanceSerializer.cs
new file mode 100644
index 0000000..6c7b3ba
--- /dev/null
+++ b/src/RailEnterprise.Core/Persistence/FinanceSerializer.cs
@@ -0,0 +1,92 @@
+using RailEnterprise.Core.Economy;
+using RailEnterprise.Core.Simulation;
+
+namespace RailEnterprise.Core.Persistence;
+
+///
+/// Conti delle compagnie (corpo del salvataggio dalla versione 7, ADR 0019): mesi e anni chiusi per voce
+/// del registro e misure dell'ultimo calcolo del rating. Entra nell'hash giornaliero con lo stato
+/// dinamico. Le versioni precedenti non hanno i mesi chiusi: parte da zero mesi
+/// e recupera l'ultimo anno chiuso.
+///
+public static class FinanceSerializer
+{
+ public static void Write(World w, SaveWriter s)
+ {
+ s.Write(w.Companies.Count);
+ foreach (var c in w.Companies)
+ {
+ WriteRecords(c.IncomeMonths, s);
+ WriteRecords(c.IncomeYears, s);
+ s.Write(c.RatingMargin);
+ s.Write(c.RatingLeverage);
+ s.Write(c.RatingScore);
+ s.Write(c.RatingMonths);
+ }
+ }
+
+ public static void Read(World w, SaveReader r)
+ {
+ int n = r.ReadInt32();
+ if (n != w.Companies.Count) throw new InvalidDataException($"Conti di {n} compagnie su {w.Companies.Count}");
+ foreach (var c in w.Companies)
+ {
+ ReadRecords(c.IncomeMonths, r);
+ ReadRecords(c.IncomeYears, r);
+ c.RatingMargin = r.ReadDouble();
+ c.RatingLeverage = r.ReadDouble();
+ c.RatingScore = r.ReadDouble();
+ c.RatingMonths = r.ReadInt32();
+ }
+ }
+
+ ///
+ /// Migrazione dalle versioni 1–6: nessun mese chiuso conservato (il conto economico mensile e la
+ /// finestra del rating si riempiono dal mese dopo il caricamento); l'ultimo anno chiuso, se c'è, entra
+ /// negli anni; il rating resta quello salvato e la sua spiegazione usa le misure del giorno fino al
+ /// primo calcolo mensile ( = 0).
+ ///
+ public static void Migrate(World w)
+ {
+ foreach (var c in w.Companies)
+ {
+ c.IncomeMonths.Clear();
+ c.IncomeYears.Clear();
+ long yearStart = (long)(w.Clock.Year - w.Calendar.StartYear) * w.Calendar.DaysPerYear;
+ bool closedYear = w.Clock.Year > w.Calendar.StartYear && c.FoundedDay < yearStart;
+ if (closedYear && c.LastYearEntries.Any(v => v != 0))
+ c.IncomeYears.Add(new IncomeRecord { Year = w.Clock.Year - 1, Month = 0, Entries = (long[])c.LastYearEntries.Clone() });
+ c.RatingMargin = 0;
+ c.RatingLeverage = 0;
+ c.RatingScore = 0;
+ c.RatingMonths = 0;
+ }
+ }
+
+ private static void WriteRecords(List records, SaveWriter s)
+ {
+ s.Write(records.Count);
+ foreach (var m in records)
+ {
+ s.Write(m.Year);
+ s.Write(m.Month);
+ s.Write(m.Entries);
+ }
+ }
+
+ private static void ReadRecords(List into, SaveReader r)
+ {
+ into.Clear();
+ int n = r.ReadInt32();
+ for (int i = 0; i < n; i++)
+ {
+ int year = r.ReadInt32();
+ int month = r.ReadInt32();
+ var source = r.ReadInt64Array();
+ // le voci aggiunte dopo il salvataggio partono da zero
+ var entries = new long[Company.EntryCount];
+ Array.Copy(source, entries, Math.Min(source.Length, entries.Length));
+ into.Add(new IncomeRecord { Year = year, Month = month, Entries = entries });
+ }
+ }
+}
diff --git a/src/RailEnterprise.Core/Persistence/WorldSerializer.cs b/src/RailEnterprise.Core/Persistence/WorldSerializer.cs
index 1cd580a..eba713d 100644
--- a/src/RailEnterprise.Core/Persistence/WorldSerializer.cs
+++ b/src/RailEnterprise.Core/Persistence/WorldSerializer.cs
@@ -14,7 +14,7 @@ namespace RailEnterprise.Core.Persistence;
public static class WorldSerializer
{
/// Versione del corpo del salvataggio (migrazioni in ).
- public const int BodyVersion = 6;
+ public const int BodyVersion = 7;
/// Scrive l'intero mondo (impostazioni, terreno, stato dinamico, eventi).
public static void Write(World w, SaveWriter s) => Write(w, s, BodyVersion);
@@ -248,6 +248,7 @@ public static class WorldSerializer
if (version >= 4) TradingSerializer.Write(w, s);
if (version >= 5) EventSerializer.Write(w, s);
if (version >= 6) BalanceSheetSerializer.Write(w, s);
+ if (version >= 7) FinanceSerializer.Write(w, s);
}
private static void WriteRecipeStock(List items, int[] stock, SaveWriter s)
@@ -712,6 +713,9 @@ public static class WorldSerializer
// versione 6 (F6): stato patrimoniale per voce e giorni dei livelli raggiunti
if (version >= 6) BalanceSheetSerializer.Read(w, r);
else BalanceSheetSerializer.Migrate(w);
+ // versione 7 (F6): conto economico per mese e per anno, misure del rating (ADR 0019)
+ if (version >= 7) FinanceSerializer.Read(w, r);
+ else FinanceSerializer.Migrate(w);
}
private static void ReadRecipeStock(List items, int[] stock, SaveReader r)
diff --git a/src/RailEnterprise.Core/Simulation/CommandProcessor.cs b/src/RailEnterprise.Core/Simulation/CommandProcessor.cs
index 3506188..725ab01 100644
--- a/src/RailEnterprise.Core/Simulation/CommandProcessor.cs
+++ b/src/RailEnterprise.Core/Simulation/CommandProcessor.cs
@@ -93,7 +93,10 @@ public static class CommandProcessor
};
company.Loans.Add(loan);
w.Money.Transfer(Account.External, Account.Of(company.Id), c.Amount, LedgerEntry.LoanTaken);
- return result(CommandError.None, $"Prestito di {c.Amount} al {loan.AnnualRate * 100:F1}% per {loan.TermMonths / 12} anni");
+ var payment = FinanceSystem.MonthlyPayment(loan.Remaining, loan.AnnualRate, loan.MonthsLeft);
+ return result(CommandError.None,
+ $"Prestito di {c.Amount} al {FinanceOutlook.Percent(loan.AnnualRate)} fisso (base {FinanceOutlook.Percent(w.Difficulty.BaseInterestRate)} + rating {company.Rating}) " +
+ $"per {loan.TermMonths / 12} anni: rata mensile {payment}");
}
///
@@ -114,10 +117,17 @@ public static class CommandProcessor
if (loan is null) return result(CommandError.NotFound, "Prestito inesistente");
if (c.Amount.Cents <= 0) return result(CommandError.InvalidArgument, "Importo non valido");
var amount = Money.Min(c.Amount, loan.Remaining);
- if (company.Cash < amount) return result(CommandError.InsufficientFunds, "Cassa insufficiente");
+ if (company.Cash < amount)
+ return result(CommandError.InsufficientFunds, $"Cassa insufficiente: per rimborsare {amount} ci sono {Money.Max(Money.Zero, company.Cash)} in cassa");
w.Money.Transfer(Account.Of(company.Id), Account.External, amount, LedgerEntry.LoanRepaid);
loan.Remaining -= amount;
- if (loan.Remaining.Cents <= 0) company.Loans.Remove(loan);
- return result(CommandError.None, $"Rimborsati {amount}");
+ if (loan.Remaining.Cents <= 0)
+ {
+ company.Loans.Remove(loan);
+ return result(CommandError.None, $"Rimborsati {amount}: prestito estinto");
+ }
+ // rimborso parziale: stessa durata e stesso tasso, la rata scende con il residuo
+ return result(CommandError.None,
+ $"Rimborsati {amount}: restano {loan.Remaining}, nuova rata mensile {FinanceSystem.MonthlyPayment(loan.Remaining, loan.AnnualRate, loan.MonthsLeft)}");
}
}
diff --git a/src/RailEnterprise.Core/Simulation/Systems/FinanceSystem.cs b/src/RailEnterprise.Core/Simulation/Systems/FinanceSystem.cs
index 6d2ef98..dfc7ef0 100644
--- a/src/RailEnterprise.Core/Simulation/Systems/FinanceSystem.cs
+++ b/src/RailEnterprise.Core/Simulation/Systems/FinanceSystem.cs
@@ -5,62 +5,133 @@ using RailEnterprise.Core.Economy;
namespace RailEnterprise.Core.Simulation.Systems;
///
-/// Finanza delle compagnie: giorni di cassa negativa e bancarotta, rate mensili dei prestiti,
-/// rating di credito, chiusura dei conti mensili e annuali (guida 6.3).
+/// Finanza delle compagnie (guida 6.3, ADR 0019): costi d'esercizio e salari del personale dei depositi
+/// ogni giorno, giorni di cassa negativa con avvisi e bancarotta, rate mensili dei prestiti, chiusura dei
+/// conti mensili e annuali (conto economico per voce), rating di credito dagli ultimi mesi chiusi.
///
public sealed class FinanceSystem : ISimSystem
{
public string Name => "Finance";
private double[] _running = [];
+ private double[] _upkeep = [];
+ private double[] _wages = [];
public void Step(WorldContext ctx)
{
if (!ctx.IsNewDay) return;
var w = ctx.World;
PayRunningCosts(w);
+ PayDepotWages(w);
foreach (var c in w.Companies)
{
if (c.Defunct) continue;
- c.NegativeCashDays = c.Cash.IsNegative ? c.NegativeCashDays + 1 : 0;
- if (c.NegativeCashDays >= w.Difficulty.BankruptcyDays)
- {
- c.Bankrupt = true;
- ctx.World.Events.Add(new GameEvent(ctx.Day, EventKind.Finance, EventSeverity.Critical,
- $"{c.Name}: dichiarata la bancarotta dopo {c.NegativeCashDays} giorni di cassa negativa", EntityKind.Company, c.Id.Value, c.Id));
- }
+ UpdateNegativeCash(ctx, c);
}
if (ctx.IsNewMonth && ctx.Day > 0)
{
UpdateBookValues(w);
+ var closed = w.Calendar.DateOfDay(ctx.Day - 1);
foreach (var c in w.Companies)
{
if (c.Merged) continue;
if (!c.Bankrupt) PayLoans(w, c);
- c.Rating = ComputeRating(w, c);
+ CloseMonth(w, c, closed.Year, closed.Month);
+ UpdateRating(w, c);
if (!c.Bankrupt) Tiers.Evaluate(ctx, c);
- // utile del mese chiuso nell'anello dei 12 mesi (borsa, 12.2); il nuovo mese parte senza dividendi
- c.ProfitRing[c.ProfitRingIndex] = Company.OperatingProfit(c.MonthEntries);
- c.ProfitRingIndex = (c.ProfitRingIndex + 1) % c.ProfitRing.Length;
- c.DividendRing[c.ProfitRingIndex] = 0;
- Array.Clear(c.MonthEntries);
}
}
if (ctx.IsNewYear && ctx.Day > 0)
{
+ int year = w.Calendar.DateOfDay(ctx.Day - 1).Year;
foreach (var c in w.Companies)
{
+ Push(c.IncomeYears, new IncomeRecord { Year = year, Month = 0, Entries = (long[])c.YearEntries.Clone() }, w.Data.Balance.Finance.IncomeYears);
Array.Copy(c.YearEntries, c.LastYearEntries, c.YearEntries.Length);
Array.Clear(c.YearEntries);
}
}
}
- /// Costi d'esercizio giornalieri: veicoli posseduti, binari di stazione, depositi.
+ ///
+ /// Chiusura del mese: utile nell'anello dei 12 mesi della borsa (12.2) e movimenti per voce nel conto
+ /// economico mensile (ADR 0019); il nuovo mese parte senza movimenti né dividendi.
+ ///
+ private static void CloseMonth(World w, Company c, int year, int month)
+ {
+ c.ProfitRing[c.ProfitRingIndex] = Company.OperatingProfit(c.MonthEntries);
+ c.ProfitRingIndex = (c.ProfitRingIndex + 1) % c.ProfitRing.Length;
+ c.DividendRing[c.ProfitRingIndex] = 0;
+ Push(c.IncomeMonths, new IncomeRecord { Year = year, Month = month, Entries = (long[])c.MonthEntries.Clone() }, w.Data.Balance.Finance.IncomeMonths);
+ Array.Clear(c.MonthEntries);
+ }
+
+ private static void Push(List list, IncomeRecord record, int capacity)
+ {
+ list.Add(record);
+ if (list.Count > capacity) list.RemoveRange(0, list.Count - capacity);
+ }
+
+ ///
+ /// Giorni di cassa negativa (guida 6.3): primo avviso dopo finance.negativeCashNoticeDays giorni di
+ /// fila, poi quando mancano i giorni di finance.bankruptcyWarningDaysLeft; bancarotta al limite della
+ /// difficoltà (difficulty.json, bankruptcyDays). Se la cassa torna positiva il conto alla rovescia si
+ /// azzera, con un avviso solo se era durato almeno i giorni del primo avviso: una cassa che oscilla
+ /// intorno a zero non riempie le notizie.
+ ///
+ private static void UpdateNegativeCash(WorldContext ctx, Company c)
+ {
+ var w = ctx.World;
+ int notice = w.Data.Balance.Finance.NegativeCashNoticeDays;
+ if (!c.Cash.IsNegative)
+ {
+ if (c.NegativeCashDays >= notice)
+ ctx.Emit(new GameEvent(ctx.Day, EventKind.Finance, EventSeverity.Info,
+ $"{c.Name}: la cassa torna positiva dopo {Days(c.NegativeCashDays)} di scoperto, il conto alla rovescia della bancarotta si azzera",
+ EntityKind.Company, c.Id.Value, c.Id));
+ c.NegativeCashDays = 0;
+ return;
+ }
+ c.NegativeCashDays++;
+ int left = w.Difficulty.BankruptcyDays - c.NegativeCashDays;
+ if (left <= 0)
+ {
+ c.Bankrupt = true;
+ ctx.Emit(new GameEvent(ctx.Day, EventKind.Finance, EventSeverity.Critical,
+ $"{c.Name}: dichiarata la bancarotta dopo {Days(c.NegativeCashDays)} di cassa negativa", EntityKind.Company, c.Id.Value, c.Id));
+ return;
+ }
+ var warnings = w.Data.Balance.Finance.BankruptcyWarningDaysLeft;
+ if (c.NegativeCashDays == notice)
+ {
+ ctx.Emit(new GameEvent(ctx.Day, EventKind.Finance, EventSeverity.Warning,
+ $"{c.Name}: cassa negativa da {Days(c.NegativeCashDays)} ({c.Cash}); se non torna sopra zero la bancarotta arriva tra {Days(left)}",
+ EntityKind.Company, c.Id.Value, c.Id));
+ }
+ else if (Array.IndexOf(warnings, left) >= 0)
+ {
+ var severity = left == warnings[^1] ? EventSeverity.Critical : EventSeverity.Warning;
+ ctx.Emit(new GameEvent(ctx.Day, EventKind.Finance, severity,
+ $"{c.Name}: cassa negativa da {Days(c.NegativeCashDays)} ({c.Cash}), bancarotta tra {Days(left)}",
+ EntityKind.Company, c.Id.Value, c.Id));
+ }
+ }
+
+ private static string Days(int n) => n == 1 ? "1 giorno" : $"{n} giorni";
+
+ ///
+ /// Costi d'esercizio giornalieri: veicoli posseduti (voce «Esercizio dei treni») e binari di stazione
+ /// e depositi (voce «Stazioni e depositi», ADR 0019).
+ ///
private void PayRunningCosts(World w)
{
- if (_running.Length < w.Companies.Count) _running = new double[w.Companies.Count];
+ if (_running.Length < w.Companies.Count)
+ {
+ _running = new double[w.Companies.Count];
+ _upkeep = new double[w.Companies.Count];
+ }
Array.Clear(_running);
+ Array.Clear(_upkeep);
double days = w.Calendar.DaysPerYear;
foreach (var v in w.Vehicles)
{
@@ -70,16 +141,41 @@ public sealed class FinanceSystem : ISimSystem
var sp = w.Data.Construction.Stations;
foreach (var s in w.Network.Stations)
{
- if (w.Network.Nodes[s.Node.Value].Station == s.Id) _running[s.Owner.Value] += s.Platforms * sp.UpkeepPerPlatformPerYear / days;
+ if (w.Network.Nodes[s.Node.Value].Station == s.Id) _upkeep[s.Owner.Value] += s.Platforms * sp.UpkeepPerPlatformPerYear / days;
}
foreach (var d in w.Network.Depots)
{
- if (w.Network.Nodes[d.Node.Value].Depot == d.Id) _running[d.Owner.Value] += sp.DepotUpkeepPerYear[d.Size] / days;
+ if (w.Network.Nodes[d.Node.Value].Depot == d.Id) _upkeep[d.Owner.Value] += sp.DepotUpkeepPerYear[d.Size] / days;
}
for (int i = 0; i < w.Companies.Count; i++)
{
- if (_running[i] <= 0 || w.Companies[i].Defunct) continue;
- w.Money.Transfer(Account.Of(w.Companies[i].Id), Account.External, Money.FromCentsRounded(_running[i]), LedgerEntry.RunningCosts);
+ if (w.Companies[i].Defunct) continue;
+ var account = Account.Of(w.Companies[i].Id);
+ if (_running[i] > 0) w.Money.Transfer(account, Account.External, Money.FromCentsRounded(_running[i]), LedgerEntry.RunningCosts);
+ if (_upkeep[i] > 0) w.Money.Transfer(account, Account.External, Money.FromCentsRounded(_upkeep[i]), LedgerEntry.StationUpkeep);
+ }
+ }
+
+ ///
+ /// Salari giornalieri del personale presente nei depositi (operai e tecnici, sezione 9), alle paghe
+ /// delle industrie (balance.json, industry.wagePerWorkerPerMonth e wagePerStaffPerMonth): la voce
+ /// «Stipendi» della guida 6.3 (ADR 0019).
+ ///
+ private void PayDepotWages(World w)
+ {
+ if (_wages.Length < w.Companies.Count) _wages = new double[w.Companies.Count];
+ Array.Clear(_wages);
+ var ib = w.Data.Balance.Industry;
+ double daysPerMonth = w.Calendar.DaysPerMonth;
+ foreach (var d in w.Network.Depots)
+ {
+ if (!d.Owner.IsValid || d.Owner.Value >= _wages.Length || !w.Network.IsAlive(d)) continue;
+ _wages[d.Owner.Value] += (d.WorkersPresent * ib.WagePerWorkerPerMonth + d.StaffPresent * ib.WagePerStaffPerMonth) / daysPerMonth;
+ }
+ for (int i = 0; i < w.Companies.Count; i++)
+ {
+ if (_wages[i] <= 0 || w.Companies[i].Defunct) continue;
+ w.Money.Transfer(Account.Of(w.Companies[i].Id), Account.External, Money.FromCentsRounded(_wages[i]), LedgerEntry.Wages);
}
}
@@ -190,31 +286,104 @@ public sealed class FinanceSystem : ISimSystem
}
///
- /// Rating da margine operativo e leva: punteggio = pesoMargine·clamp(0,5 + margine) +
- /// pesoLeva·clamp(1 − debito/attivi), confrontato con le soglie di balance.json.
+ /// Misure del rating (ADR 0019): margine = utile operativo / ricavi dei mesi chiusi conservati
+ /// (finance.incomeMonths, 12), leva = debiti (prestiti e scoperto di cassa) / patrimonio netto
+ /// (+∞ con patrimonio non positivo e debiti).
+ /// Il margine è neutro (0) finché la finestra non è piena e ha meno di finance.ratingMinRevenueMonths
+ /// mesi con ricavi: i primi incassi, piccoli rispetto ai costi dei mesi d'avvio, non fanno crollare il
+ /// rating per poi farlo risalire il mese dopo. Con la finestra piena (o con abbastanza mesi di ricavi)
+ /// conta il margine vero; senza ricavi e in perdita è il minimo (−100 %, componente nulla).
+ ///
+ public static RatingMeasures Measures(World w, Company c)
+ {
+ var fb = w.Data.Balance.Finance;
+ long revenue = 0, profit = 0;
+ int revenueMonths = 0;
+ foreach (var m in c.IncomeMonths)
+ {
+ long r = Company.Revenue(m.Entries);
+ revenue += r;
+ profit += Company.OperatingProfit(m.Entries);
+ if (r > 0) revenueMonths++;
+ }
+ bool neutral = revenueMonths < fb.RatingMinRevenueMonths && c.IncomeMonths.Count < fb.IncomeMonths;
+ double margin = neutral ? 0 : revenue > 0 ? (double)profit / revenue : profit < 0 ? -1 : 0;
+ long debt = c.Debt.Cents + Math.Max(0, -c.Cash.Cents);
+ long equity = c.NetWorth.Cents;
+ double leverage = debt <= 0 ? 0 : equity <= 0 ? double.PositiveInfinity : (double)debt / equity;
+ return new RatingMeasures(c.IncomeMonths.Count, revenueMonths, neutral, revenue, profit, margin, debt, equity, leverage);
+ }
+
+ /// Componente del margine nel punteggio: clamp(0,5 + margine, 0, 1).
+ public static double MarginComponent(double margin) => DMath.Clamp(0.5 + margin, 0, 1);
+
+ ///
+ /// Componente della leva nel punteggio: 1 / (1 + debiti/patrimonio), cioè patrimonio / (debiti +
+ /// patrimonio): 1 senza debiti, 0 con patrimonio non positivo e debiti.
+ ///
+ public static double LeverageComponent(double leverage) =>
+ double.IsPositiveInfinity(leverage) ? 0 : DMath.Clamp(1 / (1 + Math.Max(0, leverage)), 0, 1);
+
+ /// Punteggio del rating (0–1): pesoMargine·componente del margine + pesoLeva·componente della leva.
+ public static double Score(World w, double margin, double leverage)
+ {
+ var fb = w.Data.Balance.Finance;
+ return fb.ProfitMarginWeight * MarginComponent(margin) + fb.LeverageWeight * LeverageComponent(leverage);
+ }
+
+ /// Rating di un punteggio con le soglie di balance.json (finance.ratingByScore, da AAA a C; sotto è D).
+ public static CreditRating RatingOf(World w, double score)
+ {
+ var thresholds = w.Data.Balance.Finance.RatingByScore;
+ for (int i = 0; i < thresholds.Length; i++)
+ {
+ if (score >= thresholds[i]) return (CreditRating)i;
+ }
+ return CreditRating.D;
+ }
+
+ ///
+ /// Rating di credito (guida 6.3) dalle due misure di confrontate con le soglie;
+ /// D per una compagnia in bancarotta. Non scrive nulla.
///
public static CreditRating ComputeRating(World w, Company c)
{
- var fb = w.Data.Balance.Finance;
- long[] entries = w.Clock.Day % w.Calendar.DaysPerYear < 90 ? c.LastYearEntries : c.YearEntries;
- long revenue = Company.Revenue(entries);
- long profit = Company.OperatingProfit(entries);
- double margin = revenue > 0 ? (double)profit / revenue : 0;
- double assets = Math.Max(1, c.Cash.Cents + c.AssetBookValue.Cents);
- double leverage = c.Debt.Cents / assets;
- double score = fb.ProfitMarginWeight * Math.Clamp(0.5 + margin, 0, 1) + fb.LeverageWeight * Math.Clamp(1 - leverage, 0, 1);
- if (c.Bankrupt) return CreditRating.D;
- for (int i = 0; i < fb.RatingByScore.Length; i++)
- {
- if (score >= fb.RatingByScore[i]) return (CreditRating)i;
- }
- return CreditRating.D;
+ var m = Measures(w, c);
+ return c.Bankrupt ? CreditRating.D : RatingOf(w, Score(w, m.Margin, m.Leverage));
+ }
+
+ ///
+ /// Rating mensile, dopo la chiusura del mese: calcola il rating e conserva nella compagnia le misure
+ /// usate (margine, leva, punteggio, mesi della finestra), così il quadro delle finanze lo spiega.
+ ///
+ public static void UpdateRating(World w, Company c)
+ {
+ var m = Measures(w, c);
+ c.RatingMargin = m.Margin;
+ c.RatingLeverage = m.Leverage;
+ c.RatingScore = Score(w, m.Margin, m.Leverage);
+ c.RatingMonths = m.Months;
+ c.Rating = c.Bankrupt ? CreditRating.D : RatingOf(w, c.RatingScore);
}
/// Fido massimo della compagnia secondo il livello raggiunto.
public static Money MaxLoan(World w, Company c) => Tiers.LoanLimit(c, Tiers.Def(w, c.Tier));
- /// Tasso annuo per un nuovo prestito: base della difficoltà + spread del rating.
- public static double LoanRate(World w, Company c) =>
- w.Difficulty.BaseInterestRate + w.Data.Balance.Finance.RatingSpreads[c.Rating.ToString()];
+ ///
+ /// Tasso annuo per un nuovo prestito: base della difficoltà + spread del rating attuale. Il tasso resta
+ /// fisso per tutta la durata del prestito (ADR 0019).
+ ///
+ public static double LoanRate(World w, Company c) => LoanRate(w, c.Rating);
+
+ /// Tasso annuo di un nuovo prestito con il rating indicato.
+ public static double LoanRate(World w, CreditRating rating) =>
+ w.Difficulty.BaseInterestRate + w.Data.Balance.Finance.RatingSpreads[rating.ToString()];
}
+
+///
+/// Misure del rating (ADR 0019): mesi della finestra e quanti con ricavi, margine neutro (avvio), ricavi e
+/// utile operativo dei mesi, margine, debiti (prestiti e scoperto) e patrimonio netto in centesimi,
+/// leva = debiti / patrimonio.
+///
+public readonly record struct RatingMeasures(int Months, int RevenueMonths, bool MarginNeutral, long Revenue, long Profit, double Margin,
+ long Debt, long Equity, double Leverage);
diff --git a/src/RailEnterprise.Core/Simulation/Systems/StockMarketSystem.cs b/src/RailEnterprise.Core/Simulation/Systems/StockMarketSystem.cs
index 6ed76bc..e29bb7c 100644
--- a/src/RailEnterprise.Core/Simulation/Systems/StockMarketSystem.cs
+++ b/src/RailEnterprise.Core/Simulation/Systems/StockMarketSystem.cs
@@ -362,8 +362,8 @@ public sealed class StockMarketSystem : ISimSystem
Corporate.AddYear(w, c, Corporate.Snapshot(w, c, w.Clock.Year - 1, c.LastYearEntries));
///
- /// Nuovi concorrenti (12.1): se una compagnia supera la soglia di concentrazione dei ricavi
- /// dell'anno, entra una nuova IA (al massimo una ogni pochi anni e fino al numero massimo).
+ /// Nuovi concorrenti (12.1): se una compagnia supera la soglia di concentrazione dei ricavi dei
+ /// trasporti dell'anno (), entra una nuova IA (al massimo una ogni pochi anni e fino al numero massimo).
///
private static void NewCompetitors(WorldContext ctx)
{
@@ -377,7 +377,7 @@ public sealed class StockMarketSystem : ISimSystem
{
if (c.Defunct) continue;
active++;
- long r = Company.Revenue(c.LastYearEntries);
+ long r = Company.TransportRevenue(c.LastYearEntries);
total += r;
if (r > best)
{
@@ -414,7 +414,7 @@ public static class Dividends
long held = shares.ByCompany[i];
if (held <= 0 || i == payer.Id.Value) continue;
var amount = Money.FromCentsRounded(held * perShare);
- w.Money.Transfer(Account.Of(payer.Id), Account.Of(new CompanyId(i)), amount, LedgerEntry.Dividends);
+ w.Money.Transfer(Account.Of(payer.Id), Account.Of(new CompanyId(i)), amount, LedgerEntry.Dividends, LedgerEntry.DividendsReceived);
paid += amount.Cents;
}
var rest = new Money(total.Cents - paid);
diff --git a/src/RailEnterprise.Core/Simulation/TradingCommandHandlers.cs b/src/RailEnterprise.Core/Simulation/TradingCommandHandlers.cs
index 0fcecf3..5311ce6 100644
--- a/src/RailEnterprise.Core/Simulation/TradingCommandHandlers.cs
+++ b/src/RailEnterprise.Core/Simulation/TradingCommandHandlers.cs
@@ -81,7 +81,10 @@ public static class TradingCommandHandlers
hub.UsedThisMonth += p.Units;
hub.ImportedThisMonth[good] += p.Units;
w.Goods.Imported[good] += p.Units;
- w.Money.Transfer(from, Account.External, amount, LedgerEntry.Trading);
+ // il prezzo d'importazione è Pg × (1 + dazio): il dazio va sulla sua voce (ADR 0019)
+ var duty = Money.FromCentsRounded(p.Cents * hub.Duty / (1 + hub.Duty));
+ w.Money.Transfer(from, Account.External, amount - duty, LedgerEntry.Trading);
+ w.Money.Transfer(from, Account.External, duty, LedgerEntry.Duties);
}
}
TradingMath.AddToWarehouse(s, good, bought, w.Data.GoodCount);
@@ -143,7 +146,10 @@ public static class TradingCommandHandlers
hub.UsedThisMonth += p.Units;
hub.ExportedThisMonth[good] += p.Units;
w.Goods.Exported[good] += p.Units;
- w.Money.Transfer(Account.External, to, amount, LedgerEntry.Trading);
+ // il prezzo d'esportazione è Pg × (1 − dazio): si incassa il valore a Pg e si paga il dazio (ADR 0019)
+ var duty = Money.FromCentsRounded(p.Cents * hub.Duty / (1 - hub.Duty));
+ w.Money.Transfer(Account.External, to, amount + duty, LedgerEntry.Trading);
+ w.Money.Transfer(to, Account.External, duty, LedgerEntry.Duties);
}
}
s.Stock[good] -= sold;
@@ -203,7 +209,7 @@ public static class TradingCommandHandlers
///
/// Costo di giacenza mensile (trading.storageCostPerUnitPerMonth) per ogni unità nei magazzini
- /// delle stazioni, addebitato alla compagnia proprietaria sulla voce «Commercio».
+ /// delle stazioni, addebitato alla compagnia proprietaria sulla voce «Magazzini» (ADR 0019).
///
public static void ChargeStorage(World w)
{
@@ -213,7 +219,7 @@ public static class TradingCommandHandlers
{
int units = s.StockTotal;
if (units <= 0 || !s.Owner.IsValid || s.Owner.Value >= w.Companies.Count) continue;
- w.Money.Transfer(Account.Of(s.Owner), Account.External, new Money(perUnit * units), LedgerEntry.Trading);
+ w.Money.Transfer(Account.Of(s.Owner), Account.External, new Money(perUnit * units), LedgerEntry.Storage);
}
}
diff --git a/src/RailEnterprise.Protocol/Client/ClientWorld.cs b/src/RailEnterprise.Protocol/Client/ClientWorld.cs
index a26276d..2ffa47f 100644
--- a/src/RailEnterprise.Protocol/Client/ClientWorld.cs
+++ b/src/RailEnterprise.Protocol/Client/ClientWorld.cs
@@ -53,6 +53,9 @@ public sealed class ClientWorld(GameData data)
/// Quadro della scalata (F6), su richiesta: lo usano il pannello «La tua scalata» e la barra superiore.
public ClimbReport? Climb { get; private set; }
+ /// Quadro delle finanze (F6), su richiesta: lo usa il pannello «Finanze».
+ public FinanceReport? Finance { get; private set; }
+
/// Contatore dei listini ricevuti (per aggiornare il pannello della borsa).
public int TapeVersion { get; private set; }
@@ -141,6 +144,10 @@ public sealed class ClientWorld(GameData data)
Climb = m;
DetailVersion++;
return true;
+ case FinanceReport m:
+ Finance = m;
+ DetailVersion++;
+ return true;
case MaintenanceAlert m:
Alerts.Insert(0, m);
if (Alerts.Count > AlertCapacity) Alerts.RemoveAt(Alerts.Count - 1);
@@ -162,6 +169,7 @@ public sealed class ClientWorld(GameData data)
Chronicle = null;
Market = null;
Climb = null;
+ Finance = null;
Alerts.Clear();
Summary = m.Summary;
SessionId = m.SessionId;
diff --git a/src/RailEnterprise.Protocol/Message.cs b/src/RailEnterprise.Protocol/Message.cs
index 44b5563..49ca71d 100644
--- a/src/RailEnterprise.Protocol/Message.cs
+++ b/src/RailEnterprise.Protocol/Message.cs
@@ -45,6 +45,8 @@ public enum MessageId : ushort
SaveList = 133,
/// Quadro della scalata: livelli, sblocchi, requisiti, stato patrimoniale (F6).
ClimbReport = 134,
+ /// Quadro delle finanze: conto economico per voce, rating spiegato, prestiti, bancarotta (F6).
+ FinanceReport = 135,
}
/// Messaggio del protocollo: si serializza a mano, campo per campo.
diff --git a/src/RailEnterprise.Protocol/Messages/ClientMessages.cs b/src/RailEnterprise.Protocol/Messages/ClientMessages.cs
index 85e5bcf..f030345 100644
--- a/src/RailEnterprise.Protocol/Messages/ClientMessages.cs
+++ b/src/RailEnterprise.Protocol/Messages/ClientMessages.cs
@@ -241,6 +241,8 @@ public enum DetailKind : byte
Market = 7,
/// Quadro della scalata (risposta ClimbReport, F6; Id ignorato).
Climb = 8,
+ /// Quadro delle finanze (risposta FinanceReport, F6; Id ignorato).
+ Finance = 9,
}
/// Chiede al server un dettaglio che non viaggia con le entità (aggiunto in F4).
diff --git a/src/RailEnterprise.Protocol/Messages/FinanceMessages.cs b/src/RailEnterprise.Protocol/Messages/FinanceMessages.cs
new file mode 100644
index 0000000..a80e603
--- /dev/null
+++ b/src/RailEnterprise.Protocol/Messages/FinanceMessages.cs
@@ -0,0 +1,285 @@
+using RailEnterprise.Core.Common;
+
+namespace RailEnterprise.Protocol.Messages;
+
+// Messaggi della fase F6: pannello «Finanze» definitivo. Il quadro arriva su richiesta (RequestDetail con
+// DetailKind.Finance) ed è calcolato dal server con FinanceOutlook (ADR 0019): il client lo mostra com'è,
+// senza calcolare utili, rating o rate.
+
+/// Voce del conto economico in ordine di presentazione: Kind come LedgerEntry del Core, Section 0 ricavi, 1 costi, 2 investimenti e finanziamenti.
+public sealed class FinanceLineInfo
+{
+ public const byte SectionRevenue = 0, SectionCost = 1, SectionCapital = 2;
+
+ public byte Kind { get; init; }
+ public byte Section { get; init; }
+
+ public void Write(ref SpanWriter w)
+ {
+ w.U8(Kind); w.U8(Section);
+ w.Flags(0);
+ }
+
+ public static FinanceLineInfo Read(ref SpanReader r)
+ {
+ var m = new FinanceLineInfo { Kind = r.U8(), Section = r.U8() };
+ r.Flags();
+ return m;
+ }
+}
+
+///
+/// Colonna del conto economico: Kind 0 mese in corso, 1 mese chiuso, 2 anno in corso, 3 anno chiuso;
+/// Month 1–12 (0 per gli anni); Values con le sole voci diverse da zero (Kind = LedgerEntry); utile
+/// operativo e flusso di cassa del motore.
+///
+public sealed class IncomeColumnInfo
+{
+ public const byte CurrentMonth = 0, ClosedMonth = 1, CurrentYear = 2, ClosedYear = 3;
+
+ public byte Kind { get; init; }
+ public int Year { get; init; }
+ public byte Month { get; init; }
+ public List Values { get; init; } = [];
+ public Money Profit { get; init; }
+ public Money CashFlow { get; init; }
+
+ /// Valore di una voce (zero se assente).
+ public Money Value(byte entry)
+ {
+ foreach (var v in Values)
+ {
+ if (v.Kind == entry) return v.Value;
+ }
+ return Money.Zero;
+ }
+
+ public void Write(ref SpanWriter w)
+ {
+ w.U8(Kind); w.I32(Year); w.U8(Month);
+ w.Count(Values.Count);
+ foreach (var v in Values) v.Write(ref w);
+ w.Money(Profit); w.Money(CashFlow);
+ w.Flags(0);
+ }
+
+ public static IncomeColumnInfo Read(ref SpanReader r)
+ {
+ byte kind = r.U8();
+ int year = r.I32();
+ byte month = r.U8();
+ var values = new List();
+ for (int n = r.Count(), i = 0; i < n; i++) values.Add(AmountInfo.Read(ref r));
+ var m = new IncomeColumnInfo { Kind = kind, Year = year, Month = month, Values = values, Profit = r.Money(), CashFlow = r.Money() };
+ r.Flags();
+ return m;
+ }
+}
+
+/// Soglia di un rating: punteggio minimo e tasso di un nuovo prestito con quel rating.
+public sealed class RatingThresholdInfo
+{
+ public string Rating { get; init; } = "";
+ public float MinScore { get; init; }
+ public float LoanRate { get; init; }
+
+ public void Write(ref SpanWriter w)
+ {
+ w.String(Rating); w.F32(MinScore); w.F32(LoanRate);
+ w.Flags(0);
+ }
+
+ public static RatingThresholdInfo Read(ref SpanReader r)
+ {
+ var m = new RatingThresholdInfo { Rating = r.String(), MinScore = r.F32(), LoanRate = r.F32() };
+ r.Flags();
+ return m;
+ }
+}
+
+/// Prestito in corso: capitale, residuo, tasso fisso, mesi restanti, rata, interessi della prossima rata, scadenza.
+public sealed class FinanceLoanInfo
+{
+ public int Loan { get; init; }
+ public Money Principal { get; init; }
+ public Money Remaining { get; init; }
+ public float AnnualRate { get; init; }
+ public int MonthsLeft { get; init; }
+ public Money Payment { get; init; }
+ public Money NextInterest { get; init; }
+ public long MaturityDay { get; init; }
+
+ public void Write(ref SpanWriter w)
+ {
+ w.I32(Loan); w.Money(Principal); w.Money(Remaining); w.F32(AnnualRate); w.I32(MonthsLeft); w.Money(Payment); w.Money(NextInterest); w.I64(MaturityDay);
+ w.Flags(0);
+ }
+
+ public static FinanceLoanInfo Read(ref SpanReader r)
+ {
+ var m = new FinanceLoanInfo
+ {
+ Loan = r.I32(), Principal = r.Money(), Remaining = r.Money(), AnnualRate = r.F32(), MonthsLeft = r.I32(),
+ Payment = r.Money(), NextInterest = r.Money(), MaturityDay = r.I64(),
+ };
+ r.Flags();
+ return m;
+ }
+}
+
+///
+/// Quadro delle finanze della compagnia della sessione (F6, ADR 0019): conto economico per voce (mese in
+/// corso, mesi chiusi, anno in corso, anni chiusi), spiegazione del rating, prestiti, fido e conto alla
+/// rovescia della bancarotta.
+///
+public sealed class FinanceReport : IMessage
+{
+ public MessageId Id => MessageId.FinanceReport;
+ public long Day { get; init; }
+ public int Company { get; init; }
+ public Money Cash { get; init; }
+ public Money NetWorth { get; init; }
+ public Money Loans { get; init; }
+ public Money Overdraft { get; init; }
+
+ /// Voci in ordine di presentazione e colonne del conto economico.
+ public List Lines { get; init; } = [];
+ public List Columns { get; init; } = [];
+
+ /// Rating e sua spiegazione: misure dell'ultimo calcolo, componenti, punteggio.
+ public string Rating { get; init; } = "";
+ /// Prima del primo calcolo mensile: rating iniziale dei dati, misure di oggi.
+ public bool RatingInitial { get; init; }
+ public byte RatingMonths { get; init; }
+ ///
+ /// Mesi della finestra con ricavi; con il margine vale 0 finché non ce ne
+ /// sono (o la finestra non è piena).
+ ///
+ public byte RevenueMonths { get; init; }
+ public bool MarginNeutral { get; init; }
+ public byte MinRevenueMonths { get; init; }
+ public float Margin { get; init; }
+ /// Debiti / patrimonio netto; con il patrimonio non è positivo e la leva è infinita.
+ public float Leverage { get; init; }
+ public bool LeverageUnbounded { get; init; }
+ public float MarginWeight { get; init; }
+ public float LeverageWeight { get; init; }
+ public float MarginComponent { get; init; }
+ public float LeverageComponent { get; init; }
+ public float Score { get; init; }
+ public List Thresholds { get; init; } = [];
+ ///
+ /// Gradino sopra ("" ad AAA) con la soglia, il margine che basterebbe, la leva massima e il debito da
+ /// rimborsare; con il punteggio basta già (rating
+ /// al prossimo calcolo mensile) e gli obiettivi non si calcolano.
+ ///
+ public string NextRating { get; init; } = "";
+ public float NextThreshold { get; init; }
+ public bool NextAlreadyMet { get; init; }
+ public string ScoreRating { get; init; } = "";
+ public float MarginNeeded { get; init; }
+ public bool MarginReachable { get; init; }
+ public float LeverageMax { get; init; }
+ public bool LeverageReachable { get; init; }
+ public Money DebtToRepay { get; init; }
+ /// Il rimborso indicato non supera la cassa né il residuo dei prestiti (lo scoperto non si rimborsa).
+ public bool RepayAffordable { get; init; }
+
+ /// Prestiti, fido e condizioni di un nuovo prestito (base della difficoltà + spread del rating).
+ public List LoanList { get; init; } = [];
+ public Money MaxLoan { get; init; }
+ public Money LoanAvailable { get; init; }
+ public float NewLoanRate { get; init; }
+ public float BaseRate { get; init; }
+ public float Spread { get; init; }
+ public int LoanTermMonths { get; init; }
+ public Money LoanStep { get; init; }
+ public bool LoansAllowed { get; init; } = true;
+
+ /// Giorni di cassa negativa e limite della difficoltà prima della bancarotta.
+ public int NegativeCashDays { get; init; }
+ public int BankruptcyDays { get; init; }
+ public bool Bankrupt { get; init; }
+ public bool Receivership { get; init; }
+
+ public void Write(ref SpanWriter w)
+ {
+ w.I64(Day); w.I32(Company); w.Money(Cash); w.Money(NetWorth); w.Money(Loans); w.Money(Overdraft);
+ w.Count(Lines.Count);
+ foreach (var l in Lines) l.Write(ref w);
+ w.Count(Columns.Count);
+ foreach (var c in Columns) c.Write(ref w);
+ w.String(Rating); w.Bool(RatingInitial); w.U8(RatingMonths); w.U8(RevenueMonths); w.Bool(MarginNeutral); w.U8(MinRevenueMonths); w.F32(Margin); w.F32(Leverage); w.Bool(LeverageUnbounded);
+ w.F32(MarginWeight); w.F32(LeverageWeight); w.F32(MarginComponent); w.F32(LeverageComponent); w.F32(Score);
+ w.Count(Thresholds.Count);
+ foreach (var t in Thresholds) t.Write(ref w);
+ w.String(NextRating); w.F32(NextThreshold); w.Bool(NextAlreadyMet); w.String(ScoreRating);
+ w.F32(MarginNeeded); w.Bool(MarginReachable); w.F32(LeverageMax); w.Bool(LeverageReachable);
+ w.Money(DebtToRepay); w.Bool(RepayAffordable);
+ w.Count(LoanList.Count);
+ foreach (var l in LoanList) l.Write(ref w);
+ w.Money(MaxLoan); w.Money(LoanAvailable); w.F32(NewLoanRate); w.F32(BaseRate); w.F32(Spread); w.I32(LoanTermMonths); w.Money(LoanStep);
+ w.Bool(LoansAllowed);
+ w.I32(NegativeCashDays); w.I32(BankruptcyDays); w.Bool(Bankrupt); w.Bool(Receivership);
+ w.Flags(0);
+ }
+
+ public static FinanceReport Read(ref SpanReader r)
+ {
+ long day = r.I64();
+ int company = r.I32();
+ var cash = r.Money();
+ var worth = r.Money();
+ var loans = r.Money();
+ var overdraft = r.Money();
+ var lines = new List();
+ for (int n = r.Count(), i = 0; i < n; i++) lines.Add(FinanceLineInfo.Read(ref r));
+ var columns = new List();
+ for (int n = r.Count(), i = 0; i < n; i++) columns.Add(IncomeColumnInfo.Read(ref r));
+ string rating = r.String();
+ bool initial = r.Bool();
+ byte months = r.U8(), revenueMonths = r.U8();
+ bool neutral = r.Bool();
+ byte minRevenueMonths = r.U8();
+ float margin = r.F32(), leverage = r.F32();
+ bool unbounded = r.Bool();
+ float marginWeight = r.F32(), leverageWeight = r.F32(), marginComponent = r.F32(), leverageComponent = r.F32(), score = r.F32();
+ var thresholds = new List();
+ for (int n = r.Count(), i = 0; i < n; i++) thresholds.Add(RatingThresholdInfo.Read(ref r));
+ string next = r.String();
+ float nextThreshold = r.F32();
+ bool alreadyMet = r.Bool();
+ string scoreRating = r.String();
+ float marginNeeded = r.F32();
+ bool marginReachable = r.Bool();
+ float leverageMax = r.F32();
+ bool leverageReachable = r.Bool();
+ var repay = r.Money();
+ bool affordable = r.Bool();
+ var loanList = new List();
+ for (int n = r.Count(), i = 0; i < n; i++) loanList.Add(FinanceLoanInfo.Read(ref r));
+ var maxLoan = r.Money();
+ var available = r.Money();
+ float newRate = r.F32(), baseRate = r.F32(), spread = r.F32();
+ int term = r.I32();
+ var step = r.Money();
+ bool allowed = r.Bool();
+ int negDays = r.I32(), limit = r.I32();
+ bool bankrupt = r.Bool(), receivership = r.Bool();
+ r.Flags();
+ return new FinanceReport
+ {
+ Day = day, Company = company, Cash = cash, NetWorth = worth, Loans = loans, Overdraft = overdraft,
+ Lines = lines, Columns = columns,
+ Rating = rating, RatingInitial = initial, RatingMonths = months, RevenueMonths = revenueMonths, MarginNeutral = neutral,
+ MinRevenueMonths = minRevenueMonths, Margin = margin, Leverage = leverage, LeverageUnbounded = unbounded,
+ MarginWeight = marginWeight, LeverageWeight = leverageWeight, MarginComponent = marginComponent, LeverageComponent = leverageComponent,
+ Score = score, Thresholds = thresholds,
+ NextRating = next, NextThreshold = nextThreshold, NextAlreadyMet = alreadyMet, ScoreRating = scoreRating, MarginNeeded = marginNeeded, MarginReachable = marginReachable,
+ LeverageMax = leverageMax, LeverageReachable = leverageReachable, DebtToRepay = repay, RepayAffordable = affordable,
+ LoanList = loanList, MaxLoan = maxLoan, LoanAvailable = available, NewLoanRate = newRate, BaseRate = baseRate, Spread = spread,
+ LoanTermMonths = term, LoanStep = step, LoansAllowed = allowed,
+ NegativeCashDays = negDays, BankruptcyDays = limit, Bankrupt = bankrupt, Receivership = receivership,
+ };
+ }
+}
diff --git a/src/RailEnterprise.Protocol/Messages/MessageCodec.cs b/src/RailEnterprise.Protocol/Messages/MessageCodec.cs
index bb5bd4d..72ddbea 100644
--- a/src/RailEnterprise.Protocol/Messages/MessageCodec.cs
+++ b/src/RailEnterprise.Protocol/Messages/MessageCodec.cs
@@ -33,6 +33,7 @@ public static class MessageCodec
MessageId.Chronicle => Chronicle.Read(ref r),
MessageId.MarketReport => MarketReport.Read(ref r),
MessageId.ClimbReport => ClimbReport.Read(ref r),
+ MessageId.FinanceReport => FinanceReport.Read(ref r),
MessageId.MarketTape => MarketTape.Read(ref r),
MessageId.CommandResult => CommandResultMessage.Read(ref r),
MessageId.Notification => Notification.Read(ref r),
diff --git a/src/RailEnterprise.Server/GameHost.cs b/src/RailEnterprise.Server/GameHost.cs
index 4ce4f76..db976a1 100644
--- a/src/RailEnterprise.Server/GameHost.cs
+++ b/src/RailEnterprise.Server/GameHost.cs
@@ -664,6 +664,9 @@ public sealed class GameHost : IDisposable
case DetailKind.Climb:
if (s.Company.IsValid && s.Company.Value < w.Companies.Count) s.Send(Projection.Climb(w, s.Company));
break;
+ case DetailKind.Finance:
+ if (s.Company.IsValid && s.Company.Value < w.Companies.Count) s.Send(Projection.Finance(w, s.Company));
+ break;
}
}
diff --git a/src/RailEnterprise.Server/Projection.cs b/src/RailEnterprise.Server/Projection.cs
index 3a36939..ecf8a20 100644
--- a/src/RailEnterprise.Server/Projection.cs
+++ b/src/RailEnterprise.Server/Projection.cs
@@ -589,6 +589,42 @@ public static class Projection
};
}
+ /// Quadro delle finanze per la compagnia della sessione (FinanceOutlook, ADR 0019).
+ public static FinanceReport Finance(World w, CompanyId company)
+ {
+ var report = FinanceOutlook.Build(w, company);
+ var r = report.Rating;
+ static float F(double v) => (float)Math.Clamp(v, float.MinValue, float.MaxValue);
+ return new FinanceReport
+ {
+ Day = report.Day, Company = report.Company.Value, Cash = report.Cash, NetWorth = report.NetWorth, Loans = report.Loans, Overdraft = report.Overdraft,
+ Lines = report.Lines.Select(l => new FinanceLineInfo { Kind = (byte)l.Entry, Section = (byte)l.Section }).ToList(),
+ Columns = report.Columns.Select(c => new IncomeColumnInfo
+ {
+ Kind = (byte)c.Kind, Year = c.Year, Month = (byte)c.Month, Profit = c.Profit, CashFlow = c.CashFlow,
+ Values = c.Entries.Select((v, i) => (v, i)).Where(x => x.v != 0).Select(x => new AmountInfo { Kind = (byte)x.i, Value = new Money(x.v) }).ToList(),
+ }).ToList(),
+ Rating = r.Rating.ToString(), RatingInitial = r.Initial, RatingMonths = (byte)Math.Clamp(r.Months, 0, 255),
+ RevenueMonths = (byte)Math.Clamp(r.RevenueMonths, 0, 255), MarginNeutral = r.MarginNeutral, MinRevenueMonths = (byte)Math.Clamp(r.MinRevenueMonths, 0, 255),
+ Margin = F(r.Margin), Leverage = r.LeverageUnbounded ? 0 : F(r.Leverage), LeverageUnbounded = r.LeverageUnbounded,
+ MarginWeight = (float)r.MarginWeight, LeverageWeight = (float)r.LeverageWeight, MarginComponent = (float)r.MarginComponent,
+ LeverageComponent = (float)r.LeverageComponent, Score = (float)r.Score,
+ Thresholds = r.Thresholds.Select(t => new RatingThresholdInfo { Rating = t.Rating.ToString(), MinScore = (float)t.MinScore, LoanRate = (float)t.LoanRate }).ToList(),
+ NextRating = r.Next?.ToString() ?? "", NextThreshold = (float)r.NextThreshold,
+ NextAlreadyMet = r.NextAlreadyMet, ScoreRating = r.ScoreRating.ToString(), MarginNeeded = F(r.MarginNeeded), MarginReachable = r.MarginReachable,
+ LeverageMax = F(r.LeverageMax), LeverageReachable = r.LeverageReachable, DebtToRepay = r.DebtToRepay,
+ RepayAffordable = r.RepayAffordable,
+ LoanList = report.LoanList.Select(l => new FinanceLoanInfo
+ {
+ Loan = l.Id.Value, Principal = l.Principal, Remaining = l.Remaining, AnnualRate = (float)l.AnnualRate, MonthsLeft = l.MonthsLeft,
+ Payment = l.Payment, NextInterest = l.NextInterest, MaturityDay = l.MaturityDay,
+ }).ToList(),
+ MaxLoan = report.MaxLoan, LoanAvailable = report.LoanAvailable, NewLoanRate = (float)report.NewLoanRate, BaseRate = (float)report.BaseRate,
+ Spread = (float)report.Spread, LoanTermMonths = report.LoanTermMonths, LoanStep = report.LoanStep, LoansAllowed = report.LoansAllowed,
+ NegativeCashDays = report.NegativeCashDays, BankruptcyDays = report.BankruptcyDays, Bankrupt = report.Bankrupt, Receivership = report.Receivership,
+ };
+ }
+
/// Evento del mondo in corso → record del protocollo (ADR 0017).
public static WorldEventInfo WorldEvent(ActiveWorldEvent e) => new()
{
diff --git a/src/RailEnterprise.Tools/Commands/SimulateCommand.cs b/src/RailEnterprise.Tools/Commands/SimulateCommand.cs
index c4bb225..9e3818b 100644
--- a/src/RailEnterprise.Tools/Commands/SimulateCommand.cs
+++ b/src/RailEnterprise.Tools/Commands/SimulateCommand.cs
@@ -90,10 +90,10 @@ public sealed class SimulateCommand : IToolCommand
csv.AppendLine(string.Join(';', year.ToString(It), "", def.Id, Dec(price), produced.ToString(It), consumed.ToString(It),
population.ToString(It), Dec(efficiency), "", Dec(plant), "", "", "", note));
}
- long totalCarrier = w.Companies.Sum(c => Company.Revenue(c.LastYearEntries));
+ long totalCarrier = w.Companies.Sum(c => Company.TransportRevenue(c.LastYearEntries));
foreach (var c in w.Companies)
{
- long revenue = Company.Revenue(c.LastYearEntries);
+ long revenue = Company.TransportRevenue(c.LastYearEntries);
double share = totalCarrier > 0 ? (double)revenue / totalCarrier : 0;
string note = $"{(c.IsPlayer ? "giocatore" : c.AiPersonality)}, rating {c.Rating}, livello {c.Tier}{(c.Bankrupt ? ", bancarotta" : "")}{(c.Merged ? ", fusa" : "")}{AiNote(w, c)}";
bool fleet = w.Trains.Any(t => !t.Removed && t.Owner == c.Id && t.Vehicles.Count > 0);
diff --git a/tests/RailEnterprise.Tests/Economy/FinanceTests.cs b/tests/RailEnterprise.Tests/Economy/FinanceTests.cs
new file mode 100644
index 0000000..585f270
--- /dev/null
+++ b/tests/RailEnterprise.Tests/Economy/FinanceTests.cs
@@ -0,0 +1,654 @@
+using RailEnterprise.Core.Commands;
+using RailEnterprise.Core.Common;
+using RailEnterprise.Core.Data;
+using RailEnterprise.Core.Economy;
+using RailEnterprise.Core.Persistence;
+using RailEnterprise.Core.Rail;
+using RailEnterprise.Core.Simulation;
+using RailEnterprise.Core.Simulation.Systems;
+using RailEnterprise.Server;
+using RailEnterprise.Tests.Harness;
+using RailEnterprise.Tests.Rail;
+
+namespace RailEnterprise.Tests.Economy;
+
+/// Finanza completa: prestiti per rating, conto economico per voce, rating spiegato, bancarotta (F6, ADR 0019).
+public static class FinanceTests
+{
+ private static CommandResult Do(World w, GameCommand c)
+ {
+ w.Enqueue(c with { Issuer = w.Player.Id });
+ w.RunTicks(1);
+ return w.DrainResults().Last();
+ }
+
+ 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);
+ }
+
+ /// Valdoria con la rete merci, un treno sulla linea e i giorni di servizio indicati.
+ private static RailFixture ServedValdoria(int days)
+ {
+ var f = RailFixture.Valdoria();
+ var (mine, mill, depot) = f.BuildFreightNetwork();
+ int train = f.Train(depot, "Merci 1", ("loco_steam_1850", 1), ("wagon_hopper", 4));
+ int line = f.Ok(new CreateLineCommand("Linea 1", "#e0a526", new[] { new LineStop(new StationId(mine)), new LineStop(new StationId(mill)) }));
+ f.Ok(new AssignTrainCommand(new TrainId(train), new LineId(line)));
+ f.W.RunDays(days);
+ return f;
+ }
+
+ // ------------------------------------------------------------------ prestiti
+
+ [Test(Description = "Il tasso di un prestito è base della difficoltà + spread del rating, fissato all'accensione")]
+ public static void LoanRateIsBasePlusRatingSpreadAndFixed()
+ {
+ var w = TestWorlds.NoAi(901);
+ var c = w.Player;
+ var fb = w.Data.Balance.Finance;
+ foreach (var rating in new[] { CreditRating.AAA, CreditRating.BBB, CreditRating.CCC })
+ {
+ c.Rating = rating;
+ var r = Do(w, new TakeLoanCommand(Money.FromLire(10_000)));
+ Assert.True(r.Ok, r.Message);
+ var loan = c.Loans[^1];
+ double expected = w.Difficulty.BaseInterestRate + fb.RatingSpreads[rating.ToString()];
+ Assert.Approx(expected, loan.AnnualRate, 1e-12, $"tasso con {rating}");
+ Assert.Approx(expected, FinanceSystem.LoanRate(w, c), 1e-12);
+ Assert.True(r.Message.Contains(FinanceOutlook.Percent(expected)) && r.Message.Contains("rata mensile"), r.Message);
+ }
+ // il rating cambia, i tassi dei prestiti già accesi no
+ var rates = c.Loans.Select(l => l.AnnualRate).ToList();
+ c.Rating = CreditRating.D;
+ w.RunDays(w.Calendar.DaysPerMonth + 1);
+ Assert.SequenceEqual(rates, c.Loans.Select(l => l.AnnualRate).ToList(), "tassi fissi");
+ Assert.True(FinanceSystem.LoanRate(w, w.Player) > rates.Min(), "un nuovo prestito costa secondo il rating nuovo");
+ // tassi crescenti al peggiorare del rating
+ for (int i = 1; i <= (int)CreditRating.D; i++)
+ Assert.True(FinanceSystem.LoanRate(w, (CreditRating)i) >= FinanceSystem.LoanRate(w, (CreditRating)(i - 1)), $"spread di {(CreditRating)i}");
+ }
+
+ [Test(Description = "Il fido è il fido iniziale per il fattore del livello; oltre si rifiuta con un messaggio chiaro e senza effetti")]
+ public static void CreditLimitComesFromTheTierFactor()
+ {
+ var w = TestWorlds.NoAi(902);
+ var c = w.Player;
+ var tiers = w.Data.Tiers.Tiers;
+ Assert.Equal(c.BaseCredit * tiers[0].Unlocks.MaxLoanFactor, FinanceSystem.MaxLoan(w, c));
+ Assert.True(Do(w, new TakeLoanCommand(FinanceSystem.MaxLoan(w, c))).Ok, "tutto il fido");
+ var (loans, debt, cashBefore) = (c.Loans.Count, c.Debt, c.Cash);
+ var refused = Do(w, new TakeLoanCommand(Money.FromLire(1)));
+ Assert.Equal(CommandError.CreditLimit, refused.Error);
+ Assert.True(refused.Message.StartsWith("Fido insufficiente: disponibili ₤ 0"), refused.Message);
+ Assert.Equal(CommandError.InvalidArgument, Do(w, new TakeLoanCommand(Money.Zero)).Error);
+ Assert.Equal((loans, debt), (c.Loans.Count, c.Debt), "i rifiuti non cambiano i prestiti");
+ Assert.True(c.Cash <= cashBefore, "nessun incasso dai rifiuti");
+
+ var higher = tiers.First(t => t.Unlocks.MaxLoanFactor > tiers[0].Unlocks.MaxLoanFactor);
+ c.Tier = higher.Level;
+ Assert.Equal(c.BaseCredit * higher.Unlocks.MaxLoanFactor, FinanceSystem.MaxLoan(w, c));
+ Assert.True(Do(w, new TakeLoanCommand(Money.FromLire(1))).Ok, "il livello alza il fido");
+
+ // in amministrazione controllata niente prestiti nuovi
+ c.Receivership = true;
+ Assert.Equal(CommandError.NotAllowed, Do(w, new TakeLoanCommand(Money.FromLire(1))).Error);
+ Assert.False(FinanceOutlook.Build(w, c.Id).LoansAllowed, "il quadro lo dice");
+ }
+
+ [Test(Description = "Interessi e quota capitale si pagano ogni mese sul registro, alla francese, con il denaro che torna a zero")]
+ public static void MonthlyInterestIsBookedOnTheLedger()
+ {
+ var w = TestWorlds.NoAi(903);
+ var c = w.Player;
+ Assert.True(Do(w, new TakeLoanCommand(Money.FromLire(120_000))).Ok);
+ var loan = c.Loans[0];
+ var interest = Money.FromCentsRounded(loan.Remaining.Cents * loan.AnnualRate / 12);
+ var payment = FinanceSystem.MonthlyPayment(loan.Remaining, loan.AnnualRate, loan.MonthsLeft);
+ var remaining = loan.Remaining;
+ long interestBefore = c.MonthEntries[(int)LedgerEntry.Interest], repaidBefore = c.MonthEntries[(int)LedgerEntry.LoanRepaid];
+ // la rata si paga il primo giorno del mese e finisce nel mese che si chiude
+ w.RunDays(w.Calendar.DaysPerMonth - (int)(w.Clock.Day % w.Calendar.DaysPerMonth));
+ var closed = c.IncomeMonths[^1].Entries;
+ Assert.Equal(-interest.Cents, closed[(int)LedgerEntry.Interest] - interestBefore, "interessi del mese");
+ Assert.Equal(-(payment - interest).Cents, closed[(int)LedgerEntry.LoanRepaid] - repaidBefore, "quota capitale");
+ Assert.Equal(remaining - (payment - interest), loan.Remaining);
+ Assert.Equal(c.Loans[0].MonthsLeft, w.Data.Balance.Finance.LoanTermMonths - 1);
+ Assert.Equal(0L, w.MoneyBalanceSum());
+ // il quadro mostra rata e scadenza coerenti
+ var detail = FinanceOutlook.Build(w, c.Id).LoanList[0];
+ Assert.Equal(FinanceSystem.MonthlyPayment(loan.Remaining, loan.AnnualRate, loan.MonthsLeft), detail.Payment);
+ Assert.Equal(w.Clock.Day / w.Calendar.DaysPerMonth * w.Calendar.DaysPerMonth + (long)loan.MonthsLeft * w.Calendar.DaysPerMonth, detail.MaturityDay);
+ }
+
+ [Test(Description = "Rimborso anticipato parziale (rata più bassa, stessa durata) e totale; cassa insufficiente e prestito inesistente rifiutati")]
+ public static void EarlyRepaymentPartialAndTotal()
+ {
+ var w = TestWorlds.NoAi(904);
+ var c = w.Player;
+ Assert.True(Do(w, new TakeLoanCommand(Money.FromLire(100_000))).Ok);
+ var loan = c.Loans[0];
+ var payment = FinanceSystem.MonthlyPayment(loan.Remaining, loan.AnnualRate, loan.MonthsLeft);
+ int months = loan.MonthsLeft;
+
+ var partial = Do(w, new RepayLoanCommand(loan.Id, Money.FromLire(40_000)));
+ Assert.True(partial.Ok, partial.Message);
+ Assert.Equal(Money.FromLire(60_000), loan.Remaining);
+ Assert.Equal(months, loan.MonthsLeft, "la durata non cambia");
+ var lower = FinanceSystem.MonthlyPayment(loan.Remaining, loan.AnnualRate, loan.MonthsLeft);
+ Assert.True(lower < payment, "la rata scende");
+ Assert.True(partial.Message.Contains($"nuova rata mensile {lower}"), partial.Message);
+
+ // cassa insufficiente: rifiuto con gli importi, nulla cambia
+ var cash = c.Cash;
+ SetCash(w, c, Money.FromLire(1_000));
+ var owed = loan.Remaining;
+ var poor = Do(w, new RepayLoanCommand(loan.Id, loan.Remaining));
+ Assert.Equal(CommandError.InsufficientFunds, poor.Error);
+ Assert.True(poor.Message.Contains("Cassa insufficiente") && poor.Message.Contains(loan.Remaining.ToString()), poor.Message);
+ Assert.Equal(owed, loan.Remaining, "il rifiuto non rimborsa nulla");
+ SetCash(w, c, cash);
+
+ Assert.Equal(CommandError.NotFound, Do(w, new RepayLoanCommand(new LoanId(999), Money.FromLire(1))).Error);
+ var total = Do(w, new RepayLoanCommand(loan.Id, Money.FromLire(1_000_000)));
+ Assert.True(total.Ok && total.Message.Contains("prestito estinto"), total.Message);
+ Assert.Equal(0, c.Loans.Count);
+ Assert.Equal(Money.Zero, c.Debt);
+ Assert.Equal(0L, w.MoneyBalanceSum());
+ }
+
+ // ------------------------------------------------------------------ rating
+
+ /// Mese chiuso con i ricavi e i costi indicati (centesimi), per costruire la finestra del rating.
+ private static IncomeRecord Month(int year, int month, long revenue, long cost)
+ {
+ var e = new long[Company.EntryCount];
+ e[(int)LedgerEntry.FreightRevenue] = revenue;
+ e[(int)LedgerEntry.RunningCosts] = -cost;
+ return new IncomeRecord { Year = year, Month = month, Entries = e };
+ }
+
+ [Test(Description = "Il rating è funzione documentata di utile/ricavi (12 mesi) e debiti/patrimonio; le misure restano per spiegarlo")]
+ public static void RatingComesFromMarginAndLeverage()
+ {
+ var w = TestWorlds.NoAi(905);
+ var c = w.Player;
+ var fb = w.Data.Balance.Finance;
+ c.IncomeMonths.Clear();
+ for (int m = 1; m <= 12; m++) c.IncomeMonths.Add(Month(1850, m, 100_000_00, 80_000_00)); // margine 20 %
+ FinanceSystem.UpdateRating(w, c);
+ Assert.Approx(0.2, c.RatingMargin, 1e-12, "margine");
+ Assert.Equal(12, c.RatingMonths);
+ long debt = c.Debt.Cents + Math.Max(0, -c.Cash.Cents);
+ Assert.Approx(debt == 0 ? 0 : (double)debt / c.NetWorth.Cents, c.RatingLeverage, 1e-12, "leva");
+ double score = fb.ProfitMarginWeight * Math.Clamp(0.5 + 0.2, 0, 1) + fb.LeverageWeight * (1 / (1 + c.RatingLeverage));
+ Assert.Approx(score, c.RatingScore, 1e-12, "punteggio");
+ Assert.Equal(FinanceSystem.RatingOf(w, score), c.Rating);
+ var noDebt = c.Rating;
+
+ // più debito (stesso patrimonio): leva più alta, rating non migliore
+ Assert.True(Do(w, new TakeLoanCommand(FinanceSystem.MaxLoan(w, c))).Ok);
+ FinanceSystem.UpdateBookValues(w);
+ FinanceSystem.UpdateRating(w, c);
+ Assert.Approx((double)c.Debt.Cents / c.NetWorth.Cents, c.RatingLeverage, 1e-12, "debiti/patrimonio");
+ Assert.True(c.Rating >= noDebt, $"con debito {c.Rating}, senza {noDebt}");
+
+ // margine negativo: rating non migliore; margine alto: non peggiore
+ var leveraged = c.Rating;
+ for (int i = 0; i < 12; i++) c.IncomeMonths[i] = Month(1850, i + 1, 100_000_00, 150_000_00);
+ FinanceSystem.UpdateRating(w, c);
+ Assert.Approx(-0.5, c.RatingMargin, 1e-12);
+ Assert.True(c.Rating >= leveraged, "in perdita il rating non sale");
+ for (int i = 0; i < 12; i++) c.IncomeMonths[i] = Month(1850, i + 1, 100_000_00, 10_000_00);
+ FinanceSystem.UpdateRating(w, c);
+ Assert.True(c.Rating <= leveraged, "con il 90 % di margine il rating non scende");
+
+ // patrimonio negativo con debiti: leva infinita, componente nulla
+ SetCash(w, c, Money.FromLire(-10_000_000));
+ FinanceSystem.UpdateRating(w, c);
+ Assert.True(double.IsPositiveInfinity(c.RatingLeverage), "leva infinita");
+ Assert.Approx(fb.ProfitMarginWeight * 1.0, c.RatingScore, 1e-12);
+ c.Bankrupt = true;
+ FinanceSystem.UpdateRating(w, c);
+ Assert.Equal(CreditRating.D, c.Rating, "in bancarotta è D");
+ }
+
+ [Test(Description = "La spiegazione del rating dice cosa serve per salire: il margine o la leva indicati portano al gradino sopra")]
+ public static void RatingExplanationReachesTheNextNotch()
+ {
+ var w = TestWorlds.NoAi(906);
+ var c = w.Player;
+ var fb = w.Data.Balance.Finance;
+ Assert.True(Do(w, new TakeLoanCommand(Money.FromLire(200_000))).Ok);
+ c.IncomeMonths.Clear();
+ for (int m = 1; m <= 12; m++) c.IncomeMonths.Add(Month(1850, m, 100_000_00, 95_000_00)); // margine 5 %
+ FinanceSystem.UpdateBookValues(w);
+ FinanceSystem.UpdateRating(w, c);
+ var e = FinanceOutlook.Explain(w, c);
+ Assert.False(e.Initial, "misure dell'ultimo calcolo");
+ Assert.Equal(c.Rating, e.Rating);
+ Assert.Approx(c.RatingScore, e.Score, 1e-12);
+ Assert.Equal(fb.RatingByScore.Length, e.Thresholds.Count);
+ Assert.True(e.Next is not null, "c'è un gradino sopra");
+ Assert.Approx(fb.RatingByScore[(int)e.Next!.Value], e.NextThreshold, 1e-12);
+ Assert.True(e.Score < e.NextThreshold && e.Score >= (c.Rating == CreditRating.D ? 0 : fb.RatingByScore[(int)c.Rating]), "punteggio tra le due soglie");
+ if (e.MarginReachable)
+ Assert.Equal(e.Next.Value, FinanceSystem.RatingOf(w, FinanceSystem.Score(w, e.MarginNeeded + 1e-9, c.RatingLeverage)), "con il margine indicato si sale");
+ if (e.LeverageReachable)
+ {
+ Assert.Equal(e.Next.Value, FinanceSystem.RatingOf(w, FinanceSystem.Score(w, c.RatingMargin, e.LeverageMax - 1e-9)), "con la leva indicata si sale");
+ // rimborsando il debito indicato la leva scende sotto il massimo (il patrimonio non cambia)
+ var live = FinanceSystem.Measures(w, c);
+ Assert.True((double)(live.Debt - e.DebtToRepay.Cents) / live.Equity <= e.LeverageMax + 1e-9, "debito da rimborsare");
+ Assert.True(e.RepayAffordable == (e.DebtToRepay <= Money.Min(c.Debt, Money.Max(Money.Zero, c.Cash))), "rimborso possibile con la cassa");
+ }
+ Assert.True(e.MarginReachable || e.LeverageReachable, "almeno una via per salire");
+ Assert.False(e.NextAlreadyMet, "il punteggio non basta ancora");
+
+ // pochi contanti e molti attivi non monetari: il rimborso che servirebbe supera la cassa, quindi oggi
+ // non è percorribile (si rimborsa con la cassa; lo scoperto non si rimborsa)
+ SetCash(w, c, Money.FromLire(10_000));
+ c.BookValues[(int)AssetCategory.Vehicles] += Money.FromLire(400_000).Cents;
+ var poor = FinanceOutlook.Explain(w, c);
+ Assert.True(poor.LeverageReachable && poor.DebtToRepay > c.Cash && !poor.RepayAffordable, $"rimborso {poor.DebtToRepay} con cassa {c.Cash}");
+ SetCash(w, c, Money.FromLire(-1));
+ Assert.False(FinanceOutlook.Explain(w, c).RepayAffordable, "con la cassa negativa nessun rimborso");
+ }
+
+ [Test(Description = "Se il punteggio basta già per il gradino sopra (rating iniziale o rimasto indietro) la spiegazione lo dice senza obiettivi né infiniti")]
+ public static void RatingExplanationWhenTheScoreAlreadyMeetsTheNextNotch()
+ {
+ var fb = TestData.Data.Balance.Finance;
+ // partita nuova: rating iniziale dei dati, misure di oggi (margine neutro, nessun debito)
+ var fresh = TestWorlds.NoAi(907);
+ var first = FinanceOutlook.Explain(fresh, fresh.Player);
+ Assert.True(first.Initial);
+ Assert.Equal(fb.StartingRating, first.Rating);
+ Assert.True(first.MarginNeutral, "nessun mese chiuso: margine neutro");
+ Assert.True(first.Score >= first.NextThreshold, $"con i dati attuali il punteggio iniziale {first.Score} supera la soglia {first.NextThreshold}");
+ Assert.True(first.NextAlreadyMet, "il punteggio basta già");
+ Assert.Equal(FinanceSystem.RatingOf(fresh, first.Score), first.ScoreRating);
+ Assert.False(first.MarginReachable || first.LeverageReachable, "nessun obiettivo da raggiungere");
+ Assert.Approx(0, first.MarginNeeded, 1e-12);
+ Assert.Approx(0, first.LeverageMax, 1e-12);
+ var message = Projection.Finance(fresh, fresh.Player.Id);
+ Assert.True(message.NextAlreadyMet && message.ScoreRating == first.ScoreRating.ToString(), "nel protocollo");
+
+ // rating rimasto a D dopo una bancarotta risolta, con un punteggio normale: niente leva infinita
+ var w = TestWorlds.NoAi(908);
+ var c = w.Player;
+ for (int m = 1; m <= 12; m++) c.IncomeMonths.Add(Month(1850, m, 100_000_00, 95_000_00));
+ FinanceSystem.UpdateRating(w, c);
+ c.Rating = CreditRating.D;
+ var e = FinanceOutlook.Explain(w, c);
+ Assert.True(e.NextAlreadyMet && e.Next == CreditRating.C, "il punteggio vale già più di C");
+ Assert.True(double.IsFinite(e.LeverageMax) && double.IsFinite(e.MarginNeeded), "nessun infinito");
+ var wire = Projection.Finance(w, c.Id);
+ Assert.True(wire.LeverageMax < 1e6 && wire.MarginNeeded > -0.5 - 1e-6, $"leva {wire.LeverageMax}, margine {wire.MarginNeeded}");
+ }
+
+ [Test(Description = "I primi incassi non fanno crollare il rating: il margine resta neutro finché la finestra non ha abbastanza mesi con ricavi")]
+ public static void FirstRevenueDoesNotSinkTheRating()
+ {
+ var w = TestWorlds.NoAi(909);
+ var c = w.Player;
+ var fb = w.Data.Balance.Finance;
+ Assert.True(fb.RatingMinRevenueMonths > 1 && fb.RatingMinRevenueMonths + 3 < fb.IncomeMonths, "parametri del test");
+ // tre mesi d'avvio con soli costi, poi il primo incasso piccolo (margine vero −90 %)
+ c.IncomeMonths.Clear();
+ for (int m = 1; m <= 3; m++) c.IncomeMonths.Add(Month(1850, m, 0, 50_000_00));
+ FinanceSystem.UpdateRating(w, c);
+ var start = c.Rating;
+ Assert.Approx(0, c.RatingMargin, 1e-12, "solo costi nell'avvio: margine neutro");
+ c.IncomeMonths.Add(Month(1850, 4, 10_000_00, 50_000_00));
+ FinanceSystem.UpdateRating(w, c);
+ var m4 = FinanceSystem.Measures(w, c);
+ Assert.True(m4.MarginNeutral && m4.RevenueMonths == 1, "un solo mese con ricavi");
+ Assert.Approx(0, c.RatingMargin, 1e-12, "margine ancora neutro");
+ Assert.True((int)c.Rating - (int)start <= 1, $"primo incasso: da {start} a {c.Rating}");
+ Assert.True(FinanceOutlook.Explain(w, c).MarginNeutral, "la spiegazione lo dice");
+
+ // con abbastanza mesi di ricavi il margine conta
+ for (int m = 5; c.IncomeMonths.Count(x => Company.Revenue(x.Entries) > 0) < fb.RatingMinRevenueMonths; m++)
+ c.IncomeMonths.Add(Month(1850, m, 40_000_00, 50_000_00));
+ FinanceSystem.UpdateRating(w, c);
+ var counted = FinanceSystem.Measures(w, c);
+ Assert.False(counted.MarginNeutral, "margine vero");
+ Assert.Approx((double)counted.Profit / counted.Revenue, c.RatingMargin, 1e-12);
+ Assert.True(c.RatingMargin < 0, "in perdita");
+
+ // finestra piena senza ricavi e in perdita: margine minimo, componente nulla
+ c.IncomeMonths.Clear();
+ for (int m = 1; m <= fb.IncomeMonths; m++) c.IncomeMonths.Add(Month(1850, m, 0, 50_000_00));
+ FinanceSystem.UpdateRating(w, c);
+ Assert.Approx(-1, c.RatingMargin, 1e-12, "margine minimo");
+ Assert.Approx(0, FinanceSystem.MarginComponent(c.RatingMargin), 1e-12);
+ }
+
+ [Test(Description = "Il rating si aggiorna ogni mese sulla finestra degli ultimi 12 mesi chiusi")]
+ public static void RatingUsesTheLastTwelveClosedMonths()
+ {
+ var f = ServedValdoria(0);
+ var w = f.W;
+ var c = w.Player;
+ int months = w.Data.Balance.Finance.IncomeMonths;
+ w.RunDays((months + 2) * w.Calendar.DaysPerMonth);
+ Assert.Equal(months, c.IncomeMonths.Count, "finestra piena e non oltre");
+ Assert.Equal(months, c.RatingMonths);
+ // i mesi sono consecutivi e finiscono col mese appena chiuso
+ var last = w.Calendar.DateOfDay(w.Clock.Day / w.Calendar.DaysPerMonth * w.Calendar.DaysPerMonth - 1);
+ Assert.Equal((last.Year, last.Month), (c.IncomeMonths[^1].Year, c.IncomeMonths[^1].Month));
+ // le misure conservate sono quelle della finestra (il rating si ricalcola solo a inizio mese)
+ long revenue = c.IncomeMonths.Sum(m => Company.Revenue(m.Entries));
+ long profit = c.IncomeMonths.Sum(m => Company.OperatingProfit(m.Entries));
+ Assert.Approx(revenue > 0 ? (double)profit / revenue : 0, c.RatingMargin, 1e-12);
+ Assert.True(revenue > 0, "la linea incassa");
+ // l'anello dell'utile della borsa e i mesi del conto economico hanno la stessa fonte
+ long ring = c.AnnualProfit;
+ Assert.Equal(c.IncomeMonths.Skip(months - 12).Sum(m => Company.OperatingProfit(m.Entries)), ring);
+ }
+
+ // ------------------------------------------------------------------ conto economico
+
+ [Test(Description = "Il conto economico per voce somma esattamente all'utile operativo del motore in ogni colonna")]
+ public static void IncomeStatementSumsToOperatingProfit()
+ {
+ var f = ServedValdoria(0);
+ var w = f.W;
+ var c = w.Player;
+ Assert.True(Do(w, new TakeLoanCommand(Money.FromLire(50_000))).Ok);
+ w.RunDays(w.Calendar.DaysPerYear + 3 * w.Calendar.DaysPerMonth);
+ var report = FinanceOutlook.Build(w, c.Id);
+ Assert.Equal(Company.EntryCount, report.Lines.Count);
+ Assert.Equal(Company.EntryCount, report.Lines.Select(l => l.Entry).Distinct().Count(), "ogni voce una volta");
+ Assert.True(report.Columns.Count >= 3, "mese, mesi chiusi, anno");
+ Assert.Equal(IncomeColumnKind.CurrentMonth, report.Columns[0].Kind);
+ Assert.True(report.Columns.Any(x => x.Kind == IncomeColumnKind.Year), "un anno chiuso");
+ foreach (var col in report.Columns)
+ {
+ long operating = report.Lines.Where(l => l.Section != IncomeSection.Capital).Sum(l => col.Entries[(int)l.Entry]);
+ long all = col.Entries.Sum();
+ Assert.Equal(col.Profit.Cents, operating, $"utile {col.Kind} {col.Month}/{col.Year}");
+ Assert.Equal(Company.OperatingProfit(col.Entries), col.Profit.Cents);
+ Assert.Equal(col.CashFlow.Cents, all, "flusso di cassa");
+ }
+ Assert.Equal(Company.OperatingProfit(c.MonthEntries), report.Columns[0].Profit.Cents, "mese in corso dal registro");
+ var year = report.Columns.First(x => x.Kind == IncomeColumnKind.Year);
+ Assert.SequenceEqual(c.LastYearEntries, year.Entries, "anno chiuso = registro dell'anno precedente");
+ // la scalata mostra lo stesso utile dell'ultimo anno chiuso
+ Assert.Equal(ClimbOutlook.Income(w, c).Profit, year.Profit);
+ // voci vive: tariffe, esercizio dei treni, stazioni e depositi, interessi
+ Assert.True(year.Entries[(int)LedgerEntry.FreightRevenue] > 0, "noli");
+ Assert.True(year.Entries[(int)LedgerEntry.RunningCosts] < 0, "esercizio dei treni");
+ Assert.True(year.Entries[(int)LedgerEntry.StationUpkeep] < 0, "stazioni e depositi");
+ Assert.True(year.Entries[(int)LedgerEntry.Interest] < 0, "interessi");
+ Assert.Equal(0L, w.MoneyBalanceSum());
+ }
+
+ [Test(Description = "Il personale presente nei depositi riceve gli stipendi alle paghe delle industrie, sulla voce «Stipendi»")]
+ public static void DepotStaffIsPaidWages()
+ {
+ var f = RailFixture.Valdoria();
+ var net = f.BuildMaintenanceNetwork(partsLine: false, trainsPerLine: 0);
+ var w = f.W;
+ var depot = w.Network.Depots[net.Officina];
+ w.RunDays(w.Calendar.DaysPerMonth + 1);
+ Assert.True(depot.StaffPresent > 0 && depot.WorkersPresent > 0, $"personale presente: {depot.StaffPresent} tecnici, {depot.WorkersPresent} operai");
+ long before = w.Player.YearEntries[(int)LedgerEntry.Wages];
+ w.RunDays(1);
+ var ib = w.Data.Balance.Industry;
+ double expected = 0;
+ foreach (var d in w.Network.Depots)
+ {
+ if (d.Owner == w.Player.Id && w.Network.IsAlive(d))
+ expected += (d.WorkersPresent * ib.WagePerWorkerPerMonth + d.StaffPresent * ib.WagePerStaffPerMonth) / w.Calendar.DaysPerMonth;
+ }
+ Assert.Equal(-Money.FromCentsRounded(expected).Cents, w.Player.YearEntries[(int)LedgerEntry.Wages] - before, "stipendi del giorno");
+ Assert.True(Company.OperatingProfit(w.Player.YearEntries) < Company.OperatingProfit(w.Player.YearEntries) - w.Player.YearEntries[(int)LedgerEntry.Wages],
+ "gli stipendi riducono l'utile operativo");
+ Assert.Equal(0L, w.MoneyBalanceSum());
+ }
+
+ [Test(Description = "Dazi degli hub e giacenze dei magazzini sulle loro voci, con lo stesso netto per la cassa")]
+ public static void DutiesAndStorageHaveTheirOwnEntries()
+ {
+ var f = RailFixture.Valdoria();
+ var w = f.W;
+ w.Player.Tier = w.Data.Tiers.Tiers.First(t => t.Unlocks.Trading).Level;
+ int port = f.Ok(new BuildStationCommand(RailFixture.K(14.5, 6.3), 2, "Porto di Levante"));
+ var hub = w.Hubs[0];
+ int coal = w.Data.Goods.First(g => g.Id == "coal").Index;
+ double price = hub.SellPrice(w.Market.GlobalPrice[coal]);
+ var cash = w.Player.Cash;
+ long trading = w.Player.YearEntries[(int)LedgerEntry.Trading], duties = w.Player.YearEntries[(int)LedgerEntry.Duties];
+ var r = f.Do(new BuyGoodsCommand(new StationId(port), "coal", 60, Money.FromCentsRounded(price + 1)));
+ Assert.True(r.Ok, r.Message);
+ long paid = (cash - w.Player.Cash).Cents;
+ long duty = -(w.Player.YearEntries[(int)LedgerEntry.Duties] - duties);
+ Assert.Approx(60 * price * hub.Duty / (1 + hub.Duty), duty, 1, "dazio d'importazione");
+ Assert.Equal(-(paid - duty), w.Player.YearEntries[(int)LedgerEntry.Trading] - trading, "il resto è commercio");
+
+ // vendita all'hub: incasso a Pg e dazio a parte, netto = prezzo d'esportazione
+ cash = w.Player.Cash;
+ duties = w.Player.YearEntries[(int)LedgerEntry.Duties];
+ double sell = hub.BuyPrice(w.Market.GlobalPrice[coal]);
+ var s = f.Do(new SellGoodsCommand(new StationId(port), "coal", 20, Money.Zero));
+ Assert.True(s.Ok, s.Message);
+ Assert.Approx(20 * sell, (w.Player.Cash - cash).Cents, 1, "incasso netto");
+ Assert.True(w.Player.YearEntries[(int)LedgerEntry.Duties] < duties, "dazio d'esportazione");
+
+ // giacenza mensile sulla voce «Magazzini»
+ long storage = w.Player.YearEntries[(int)LedgerEntry.Storage];
+ f.W.RunDays(w.Calendar.DaysPerMonth + 1);
+ Assert.True(w.Player.YearEntries[(int)LedgerEntry.Storage] < storage || w.Player.LastYearEntries[(int)LedgerEntry.Storage] < 0, "giacenza addebitata");
+ Assert.Equal(0L, w.MoneyBalanceSum());
+ }
+
+ // ------------------------------------------------------------------ bancarotta
+
+ [Test(Slow = true, Description = "Cassa negativa: avviso subito e alle scadenze fisse, bancarotta esattamente ai giorni di difficulty.json per ogni preset")]
+ public static void BankruptcyFollowsTheDifficultyDays()
+ {
+ var fb = TestData.Data.Balance.Finance;
+ foreach (var preset in TestData.Data.Difficulty.Presets)
+ {
+ var w = TestWorlds.NoAi(910, preset.Id);
+ var c = w.Player;
+ Assert.Equal(preset.BankruptcyDays, w.Difficulty.BankruptcyDays, preset.Id);
+ SetCash(w, c, Money.FromLire(-1_000_000));
+ w.Events.Drain();
+ var warnings = new List<(int Day, GameEvent Event)>();
+ int days = 0;
+ while (!c.Bankrupt && days < preset.BankruptcyDays + 5)
+ {
+ w.RunDays(1);
+ days++;
+ foreach (var e in w.Events.Drain())
+ {
+ if (e.Kind == EventKind.Finance && e.Company == c.Id) warnings.Add((c.NegativeCashDays, e));
+ }
+ }
+ Assert.True(c.Bankrupt, $"{preset.Id}: bancarotta");
+ Assert.Equal(preset.BankruptcyDays, c.NegativeCashDays, $"{preset.Id}: giorni di cassa negativa");
+ Assert.Equal(preset.BankruptcyDays, days, $"{preset.Id}: giorni trascorsi");
+ int notice = fb.NegativeCashNoticeDays;
+ Assert.True(warnings[0].Day == notice && warnings[0].Event.Text.Contains($"bancarotta arriva tra {preset.BankruptcyDays - notice} giorni"),
+ $"{preset.Id}: {warnings[0].Event.Text}");
+ foreach (int left in fb.BankruptcyWarningDaysLeft.Where(l => l < preset.BankruptcyDays - notice))
+ {
+ Assert.True(warnings.Any(x => x.Day == preset.BankruptcyDays - left && x.Event.Text.Contains($"bancarotta tra {(left == 1 ? "1 giorno" : $"{left} giorni")}")),
+ $"{preset.Id}: avviso a {left} giorni");
+ }
+ var last = warnings[^1].Event;
+ Assert.True(last.Severity == EventSeverity.Critical && last.Text.Contains("dichiarata la bancarotta"), last.Text);
+ // l'esito segue la regola della difficoltà (ADR 0012): senza IA che la rilevino la partita finisce
+ w.RunDays(1);
+ Assert.True(w.GameOver is not null, $"{preset.Id}: fine partita");
+ Assert.Equal(0L, w.MoneyBalanceSum());
+ }
+ }
+
+ [Test(Description = "Se la cassa torna positiva il conto alla rovescia si azzera con un avviso; una cassa che oscilla intorno a zero non genera notizie")]
+ public static void PositiveCashResetsTheCountdown()
+ {
+ var w = TestWorlds.NoAi(911);
+ var c = w.Player;
+ var cash = c.Cash;
+ int notice = w.Data.Balance.Finance.NegativeCashNoticeDays;
+ Assert.True(notice > 1 && notice < 5, "parametri del test");
+ // oscillazioni più brevi del primo avviso: il contatore riparte, nessuna notizia
+ w.Events.Drain();
+ for (int i = 0; i < 4; i++)
+ {
+ SetCash(w, c, Money.FromLire(-50));
+ w.RunDays(notice - 1);
+ Assert.Equal(notice - 1, c.NegativeCashDays);
+ SetCash(w, c, cash);
+ w.RunDays(1);
+ Assert.Equal(0, c.NegativeCashDays, "il conto alla rovescia si azzera");
+ }
+ Assert.False(w.Events.Drain().Any(e => e.Company == c.Id && e.Kind == EventKind.Finance), "nessun avviso per le oscillazioni");
+
+ SetCash(w, c, Money.FromLire(-1_000));
+ w.RunDays(5);
+ Assert.Equal(5, c.NegativeCashDays);
+ var report = FinanceOutlook.Build(w, c.Id);
+ Assert.Equal(5, report.NegativeCashDays);
+ Assert.Equal(w.Difficulty.BankruptcyDays, report.BankruptcyDays);
+ Assert.Equal(Money.FromLire(1_000), report.Overdraft);
+ w.Events.Drain();
+ SetCash(w, c, cash);
+ w.RunDays(1);
+ Assert.Equal(0, c.NegativeCashDays);
+ Assert.True(w.Events.Drain().Any(e => e.Company == c.Id && e.Kind == EventKind.Finance && e.Text.Contains("torna positiva")), "avviso di rientro");
+ }
+
+ // ------------------------------------------------------------------ salvataggi e determinismo
+
+ [Test(Description = "Mesi e anni chiusi e misure del rating nel salvataggio (versione 7) e nell'hash; la versione 6 si migra")]
+ public static void FinanceStateSurvivesSavesAndMigrates()
+ {
+ var f = ServedValdoria(0);
+ var w = f.W;
+ var c = w.Player;
+ Assert.True(Do(w, new TakeLoanCommand(Money.FromLire(30_000))).Ok);
+ w.RunDays(w.Calendar.DaysPerYear + 2 * w.Calendar.DaysPerMonth);
+ Assert.True(c.IncomeMonths.Count > 0 && c.IncomeYears.Count > 0 && c.RatingMonths > 0, "stato da salvare");
+
+ var loaded = SaveFile.Load(TestData.Data, SaveFile.Save(w, "test"));
+ var lc = loaded.Player;
+ Assert.Equal(c.IncomeMonths.Count, lc.IncomeMonths.Count);
+ for (int i = 0; i < c.IncomeMonths.Count; i++)
+ {
+ Assert.Equal((c.IncomeMonths[i].Year, c.IncomeMonths[i].Month), (lc.IncomeMonths[i].Year, lc.IncomeMonths[i].Month));
+ Assert.SequenceEqual(c.IncomeMonths[i].Entries, lc.IncomeMonths[i].Entries);
+ }
+ Assert.SequenceEqual(c.IncomeYears[0].Entries, lc.IncomeYears[0].Entries);
+ Assert.Equal(c.RatingScore, lc.RatingScore);
+ Assert.Equal(c.RatingMargin, lc.RatingMargin);
+ Assert.Equal(StateHasher.Compute(w), StateHasher.Compute(loaded));
+
+ // i mesi entrano nell'hash
+ ulong hash = StateHasher.Compute(w);
+ c.IncomeMonths[0].Entries[(int)LedgerEntry.Wages]--;
+ Assert.NotEqual(hash, StateHasher.Compute(w), "un mese chiuso cambia l'hash");
+ c.IncomeMonths[0].Entries[(int)LedgerEntry.Wages]++;
+
+ // stesso futuro dopo il caricamento
+ w.RunDays(40);
+ loaded.RunDays(40);
+ Assert.Equal(StateHasher.Compute(w), StateHasher.Compute(loaded), "stesso futuro");
+
+ // versione 6: nessun mese conservato, l'anno chiuso dal registro, il rating resta
+ var v6 = new SaveWriter(1 << 20);
+ WorldSerializer.Write(w, v6, 6);
+ var migrated = WorldSerializer.Read(TestData.Data, new SaveReader(v6.WrittenSpan.ToArray()));
+ var mc = migrated.Player;
+ Assert.Equal(0, mc.IncomeMonths.Count);
+ Assert.Equal(0, mc.RatingMonths);
+ Assert.Equal(c.Rating, mc.Rating);
+ Assert.Equal(1, mc.IncomeYears.Count);
+ Assert.SequenceEqual(c.LastYearEntries, mc.IncomeYears[0].Entries);
+ Assert.True(FinanceOutlook.Explain(migrated, mc).Initial, "spiegazione con le misure di oggi fino al primo calcolo");
+ migrated.RunDays(w.Calendar.DaysPerMonth);
+ Assert.Equal(1, mc.IncomeMonths.Count);
+ Assert.Equal(1, mc.RatingMonths);
+ Assert.Equal(0L, migrated.MoneyBalanceSum());
+ }
+
+ [Test(Description = "Stesso seme e stessi comandi finanziari danno lo stesso hash; denaro e merci restano in equilibrio")]
+ public static void FinanceIsDeterministicAndKeepsInvariants()
+ {
+ ulong Run()
+ {
+ var f = ServedValdoria(0);
+ var w = f.W;
+ Assert.True(Do(w, new TakeLoanCommand(Money.FromLire(40_000))).Ok);
+ w.RunDays(200);
+ Assert.True(Do(w, new RepayLoanCommand(w.Player.Loans[0].Id, Money.FromLire(10_000))).Ok);
+ w.RunDays(200);
+ Assert.Equal(0L, w.MoneyBalanceSum(), "denaro");
+ for (int g = 0; g < w.Data.GoodCount; g++) Assert.Equal(w.Goods.ExpectedStock(g), w.TotalStock(g), $"merce {w.Data.Goods[g].Id}");
+ return StateHasher.Compute(w);
+ }
+ Assert.Equal(Run(), Run());
+ }
+
+ [Test(Description = "Il quadro delle finanze si proietta nel protocollo con le stesse somme del motore")]
+ public static void ProjectionMatchesTheEngine()
+ {
+ var f = ServedValdoria(2 * 30);
+ var w = f.W;
+ Assert.True(Do(w, new TakeLoanCommand(Money.FromLire(20_000))).Ok);
+ ulong hash = StateHasher.Compute(w);
+ var report = FinanceOutlook.Build(w, w.Player.Id);
+ var message = Projection.Finance(w, w.Player.Id);
+ Assert.Equal(hash, StateHasher.Compute(w), "il quadro non cambia il mondo");
+ Assert.Equal(report.Columns.Count, message.Columns.Count);
+ for (int i = 0; i < report.Columns.Count; i++)
+ {
+ Assert.Equal(report.Columns[i].Profit, message.Columns[i].Profit);
+ foreach (var line in message.Lines) Assert.Equal(report.Columns[i].Entries[line.Kind], message.Columns[i].Value(line.Kind).Cents);
+ }
+ Assert.Equal(w.Player.Rating.ToString(), message.Rating);
+ Assert.Equal(1, message.LoanList.Count);
+ Assert.Equal(report.LoanList[0].Payment, message.LoanList[0].Payment);
+ Assert.Equal(w.Difficulty.BankruptcyDays, message.BankruptcyDays);
+ }
+
+ [Test(Description = "I dividendi tra compagnie escono come dividendi pagati (fuori dall'utile) ed entrano come dividendi incassati (nell'utile)")]
+ public static void DividendsReceivedCountInOperatingProfit()
+ {
+ var w = TestWorlds.Small(912);
+ var payer = w.Companies.First(c => !c.Id.Equals(w.Player.Id));
+ var me = w.Player;
+ long profitBefore = Company.OperatingProfit(me.YearEntries), payerProfit = Company.OperatingProfit(payer.YearEntries);
+ var amount = Money.FromLire(2_500);
+ w.Money.Transfer(Account.Of(payer.Id), Account.Of(me.Id), amount, LedgerEntry.Dividends, LedgerEntry.DividendsReceived);
+ Assert.Equal(amount.Cents, me.YearEntries[(int)LedgerEntry.DividendsReceived], "incassati");
+ Assert.Equal(-amount.Cents, payer.YearEntries[(int)LedgerEntry.Dividends], "pagati");
+ Assert.Equal(profitBefore + amount.Cents, Company.OperatingProfit(me.YearEntries), "nell'utile di chi incassa");
+ Assert.Equal(payerProfit, Company.OperatingProfit(payer.YearEntries), "fuori dall'utile di chi paga");
+ Assert.Equal(IncomeSection.Revenue, LedgerEntries.Section(LedgerEntry.DividendsReceived));
+ Assert.Equal(IncomeSection.Capital, LedgerEntries.Section(LedgerEntry.Dividends));
+ Assert.Equal(0L, w.MoneyBalanceSum());
+ }
+
+ [Test(Description = "La quota dei trasporti dei nuovi concorrenti conta solo tariffe, noli e contratti, non dividendi né commercio")]
+ public static void TransportShareIgnoresDividendsAndTrading()
+ {
+ var e = new long[Company.EntryCount];
+ e[(int)LedgerEntry.FreightRevenue] = 1_000;
+ e[(int)LedgerEntry.PassengerRevenue] = 500;
+ e[(int)LedgerEntry.Contracts] = 200;
+ long transport = Company.TransportRevenue(e);
+ Assert.Equal(1_700L, transport);
+ e[(int)LedgerEntry.DividendsReceived] = 1_000_000;
+ e[(int)LedgerEntry.Trading] = 50_000;
+ e[(int)LedgerEntry.Subsidiaries] = 7_000;
+ Assert.Equal(transport, Company.TransportRevenue(e), "dividendi, commercio e controllate fuori dalla quota");
+ Assert.True(Company.Revenue(e) > transport, "restano nei ricavi del rating");
+ }
+}
diff --git a/tests/RailEnterprise.Tests/Protocol/ProtocolTests.cs b/tests/RailEnterprise.Tests/Protocol/ProtocolTests.cs
index d3e1847..5b89bc1 100644
--- a/tests/RailEnterprise.Tests/Protocol/ProtocolTests.cs
+++ b/tests/RailEnterprise.Tests/Protocol/ProtocolTests.cs
@@ -188,6 +188,29 @@ public static class ProtocolTests
MaxLoan = new Money(100_000_000), LoanAvailable = new Money(88_000_000), NewLoanRate = 0.061f, LoansAllowed = false,
History = [new NetWorthPointInfo { Day = 0, Value = new Money(25_000_000) }, new NetWorthPointInfo { Day = 2600, Value = new Money(39_144_993) }],
};
+ yield return new FinanceReport
+ {
+ Day = 2610, Company = 0, Cash = new Money(-120_000), NetWorth = new Money(39_000_000), Loans = new Money(12_000_000), Overdraft = new Money(120_000),
+ Lines = [new FinanceLineInfo { Kind = 0, Section = FinanceLineInfo.SectionRevenue }, new FinanceLineInfo { Kind = 9, Section = FinanceLineInfo.SectionCost },
+ new FinanceLineInfo { Kind = 2, Section = FinanceLineInfo.SectionCapital }],
+ Columns =
+ [
+ new IncomeColumnInfo { Kind = IncomeColumnInfo.CurrentMonth, Year = 1872, Month = 3, Values = [new AmountInfo { Kind = 0, Value = new Money(150_000) }],
+ Profit = new Money(150_000), CashFlow = new Money(150_000) },
+ new IncomeColumnInfo { Kind = IncomeColumnInfo.ClosedYear, Year = 1871, Values = [new AmountInfo { Kind = 9, Value = new Money(-66_000) }, new AmountInfo { Kind = 2, Value = new Money(-1_000) }],
+ Profit = new Money(-66_000), CashFlow = new Money(-67_000) },
+ ],
+ Rating = "BBB", RatingInitial = false, RatingMonths = 12, RevenueMonths = 9, MarginNeutral = true, MinRevenueMonths = 3, Margin = 0.28f, Leverage = 0.31f, LeverageUnbounded = false,
+ MarginWeight = 0.6f, LeverageWeight = 0.4f, MarginComponent = 0.78f, LeverageComponent = 0.76f, Score = 0.772f,
+ Thresholds = [new RatingThresholdInfo { Rating = "AAA", MinScore = 0.85f, LoanRate = 0.055f }, new RatingThresholdInfo { Rating = "C", MinScore = 0.05f, LoanRate = 0.17f }],
+ NextRating = "A", NextThreshold = 0.65f, NextAlreadyMet = true, ScoreRating = "AA", MarginNeeded = 0.31f, MarginReachable = true, LeverageMax = 0.12f, LeverageReachable = false,
+ DebtToRepay = new Money(7_000_000), RepayAffordable = true,
+ LoanList = [new FinanceLoanInfo { Loan = 4, Principal = new Money(15_000_000), Remaining = new Money(12_000_000), AnnualRate = 0.075f, MonthsLeft = 97,
+ Payment = new Money(171_234), NextInterest = new Money(75_000), MaturityDay = 5520 }],
+ MaxLoan = new Money(60_000_000), LoanAvailable = new Money(48_000_000), NewLoanRate = 0.075f, BaseRate = 0.05f, Spread = 0.025f,
+ LoanTermMonths = 120, LoanStep = new Money(5_000_000), LoansAllowed = false,
+ NegativeCashDays = 12, BankruptcyDays = 90, Bankrupt = false, Receivership = true,
+ };
yield return new CommandResultMessage { Seq = 99, Type = (ushort)CommandType.BuildTrack, Error = 10, Message = "Pendenza eccessiva", Created = [1, 2, 3], Tick = 4000 };
yield return new Notification { Event = SampleEvent() };
yield return new Newspaper { Day = 30, Title = "La Cronaca di Valdoria", Articles = [("Nuova linea", "Inaugurata la linea per il valico."), ("Prezzi", "Il carbone sale.")] };
diff --git a/tests/RailEnterprise.Tests/Server/ServerTests.cs b/tests/RailEnterprise.Tests/Server/ServerTests.cs
index 4629549..b3b9a0f 100644
--- a/tests/RailEnterprise.Tests/Server/ServerTests.cs
+++ b/tests/RailEnterprise.Tests/Server/ServerTests.cs
@@ -351,6 +351,59 @@ public static class ServerTests
Assert.Equal(Money.FromLire(5_000), after.Loans);
}
+ [Test(Description = "Il quadro delle finanze arriva su richiesta e dopo un prestito riporta il prestito nuovo (ADR 0019)")]
+ public static void FinanceReportOnRequest() => RunFinance().GetAwaiter().GetResult();
+
+ private static async Task RunFinance()
+ {
+ var scenario = ScenarioHelper.Load("valdoria");
+ int limit = scenario.World.Difficulty.BankruptcyDays;
+ await using var server = ServerFixture.Start(scenario.World);
+ await using var client = await TestClient.ConnectAsync(server);
+ var w = client.World;
+ var data = TestData.Data;
+ await client.WaitUntil(() => w.LastDigest is { Day: >= 2 }, "due giorni di partita");
+
+ // il server non manda il quadro da solo: si aspetta la risposta a questa richiesta
+ Assert.True(w.Finance is null, "nessun quadro prima della richiesta");
+ await client.Connection.SendAsync(new RequestDetail { Kind = DetailKind.Finance, Target = 0 });
+ var report = await client.WaitFor(() => w.Finance, "quadro delle finanze");
+ Assert.True(report.Day >= 2, $"giorno {report.Day}");
+ Assert.Equal(w.Summary!.CompanyId, report.Company);
+ Assert.Equal(global::RailEnterprise.Core.Economy.Company.EntryCount, report.Lines.Count);
+ Assert.Equal(IncomeColumnInfo.CurrentMonth, report.Columns[0].Kind);
+ Assert.True(report.Columns.Any(c => c.Kind == IncomeColumnInfo.CurrentYear), "colonna dell'anno in corso");
+ foreach (var col in report.Columns)
+ {
+ long operating = report.Lines.Where(l => l.Section != FinanceLineInfo.SectionCapital).Sum(l => col.Value(l.Kind).Cents);
+ Assert.Equal(col.Profit.Cents, operating, $"le voci d'esercizio sommano all'utile ({col.Kind} {col.Month}/{col.Year})");
+ }
+ Assert.Equal(data.Balance.Finance.RatingByScore.Length, report.Thresholds.Count);
+ // con TickMs = 1 il primo mese può già essere passato su una macchina lenta: il rating iniziale vale solo prima
+ int dpm = scenario.World.Calendar.DaysPerMonth;
+ if (report.Day < dpm) Assert.True(report.RatingInitial, "prima del primo mese il rating è quello iniziale");
+ Assert.Equal(limit, report.BankruptcyDays);
+ Assert.Equal(0, report.LoanList.Count);
+
+ // dopo un prestito una nuova richiesta riporta il prestito: si aspetta la risposta nuova, non quella vecchia
+ var result = await client.Do(new TakeLoanCommand(Money.FromLire(5_000)));
+ Assert.True(result.Error == 0, result.Message);
+ var stale = w.Finance;
+ await client.Connection.SendAsync(new RequestDetail { Kind = DetailKind.Finance, Target = 0 });
+ var after = await client.WaitFor(() => ReferenceEquals(w.Finance, stale) ? null : w.Finance, "quadro aggiornato");
+ Assert.Equal(1, after.LoanList.Count);
+ var loan = after.LoanList[0];
+ Assert.Equal(Money.FromLire(5_000), loan.Principal);
+ // il tasso del prestito è quello di un rating (base + spread all'accensione); se il quadro è dello stesso
+ // mese del prestito il rating non è cambiato e coincide con il tasso di un prestito nuovo
+ double baseRate = scenario.World.Difficulty.BaseInterestRate;
+ var rates = data.Balance.Finance.RatingSpreads.Values.Select(s => (float)(baseRate + s)).ToList();
+ Assert.True(rates.Any(r => Math.Abs(r - loan.AnnualRate) < 1e-6), $"tasso {loan.AnnualRate} = base + spread di un rating");
+ if (after.Day / dpm == report.Day / dpm) Assert.Approx(after.NewLoanRate, loan.AnnualRate, 1e-6, "tasso fissato all'accensione");
+ Assert.True(loan.Payment.Cents > 0 && loan.MaturityDay > after.Day, "rata e scadenza");
+ Assert.Equal(Money.FromLire(5_000), after.Loans);
+ }
+
[Test(Description = "Hello con token errato, dati diversi o protocollo vecchio riceve Reject")]
public static void HandshakeRejections() => RunRejections().GetAwaiter().GetResult();