F6: ere e obsolescenza dei veicoli #49
No files matched your search
@@ -677,6 +677,32 @@ una leva non oltre {0} (rimborsando {1}),,leverage no higher than {0} (by repayi
|
||||
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.
|
||||
Rinnovo della flotta,,Fleet renewal
|
||||
Rinnova i veicoli superati,,Renew superseded vehicles
|
||||
Rinnova,,Renew
|
||||
Era,,Era
|
||||
Prossima era,,Next era
|
||||
Valore della flotta,,Fleet value
|
||||
Nessun veicolo superato,,No superseded vehicles
|
||||
Quadro della flotta in arrivo dal server…,,Fleet overview coming from the server…
|
||||
Cassa insufficiente.,,Not enough cash.
|
||||
In produzione fino al {0}.,,In production until {0}.
|
||||
"Rinnovo: {0} veicoli superati, spesa netta {1} dopo le rivendite.",,"Renewal: {0} superseded vehicles, net cost {1} after resale."
|
||||
Seleziona i veicoli da vendere,,Select the vehicles to sell
|
||||
Superato dal {0}.,,Superseded since {0}.
|
||||
"Superato dal {0}: successore {1} ({2} kW, {3} km/h, {4}).",,"Superseded since {0}: successor {1} ({2} kW, {3} km/h, {4})."
|
||||
da rinnovare,,to renew
|
||||
e altri {0} veicoli superati,,and {0} more superseded vehicles
|
||||
fuori produzione,,out of production
|
||||
manutenzione ×{0:0.##},,maintenance ×{0:0.##}
|
||||
rivendita {0},,resale {0}
|
||||
"successore {0} ({1} kW, {2} km/h, {3})",,"successor {0} ({1} kW, {2} km/h, {3})"
|
||||
superato,,superseded
|
||||
superato dal {0},,superseded since {0}
|
||||
valore {0},,value {0}
|
||||
"{0}: {1} veicoli da rinnovare, spesa netta {2}",,"{0}: {1} vehicles to renew, net cost {2}"
|
||||
rinnovo prenotato,,renewal booked
|
||||
Rinnovo già prenotato.,,Renewal already booked.
|
||||
Audio,,Audio
|
||||
Volume generale,,Master volume
|
||||
Musica,,Music
|
||||
|
||||
|
@@ -3,6 +3,7 @@ using RailEnterprise.Client.App;
|
||||
using RailEnterprise.Client.Net;
|
||||
using RailEnterprise.Core.Commands;
|
||||
using RailEnterprise.Core.Common;
|
||||
using RailEnterprise.Core.Data;
|
||||
using RailEnterprise.Protocol.Messages;
|
||||
using static RailEnterprise.Client.App.Localization;
|
||||
|
||||
@@ -11,7 +12,8 @@ namespace RailEnterprise.Client.Panels;
|
||||
/// <summary>
|
||||
/// Officine (sezione 10.3): politica della flotta, avvisi, flotta ordinata per condizione con la
|
||||
/// mappa di calore, cartella di manutenzione del treno scelto, depositi con il Registro officina e
|
||||
/// la scorta di ricambi. Le cartelle e i registri arrivano su richiesta dal server.
|
||||
/// la scorta di ricambi, rinnovo della flotta (ere e obsolescenza, ADR 0020). Le cartelle, i registri
|
||||
/// e il quadro della flotta arrivano su richiesta dal server: età, successori e valori non si calcolano qui.
|
||||
/// </summary>
|
||||
public partial class MaintenancePanel : VBoxContainer
|
||||
{
|
||||
@@ -29,12 +31,19 @@ public partial class MaintenancePanel : VBoxContainer
|
||||
private readonly VBoxContainer _workshop = PanelKit.Column(8);
|
||||
private readonly VBoxContainer _workshopDetails = PanelKit.Column(6);
|
||||
private readonly HBoxContainer _orderRow = PanelKit.Row();
|
||||
private readonly VBoxContainer _fleet = PanelKit.Column(6);
|
||||
private readonly Label _status = UiTheme.Text("", 13, Palette.TextSecondary);
|
||||
private readonly List<int> _trainIds = [];
|
||||
private readonly List<int> _depotIds = [];
|
||||
private int _train = -1, _depot = -1;
|
||||
private int _entityVersion = -1, _detailVersion = -1;
|
||||
private double _request;
|
||||
private long _fleetDay = long.MinValue;
|
||||
private double _sinceFleet = double.MaxValue;
|
||||
// quadro della flotta mostrato: la sezione si ricostruisce solo quando ne arriva uno nuovo, così i
|
||||
// pulsanti «Rinnova» non si ricreano sotto il cursore a ogni aggiornamento della cartella
|
||||
private FleetReport? _fleetShown;
|
||||
private bool _fleetBuilt;
|
||||
private bool _updating;
|
||||
|
||||
public event Action<bool>? HeatMapToggled;
|
||||
@@ -69,6 +78,9 @@ public partial class MaintenancePanel : VBoxContainer
|
||||
AddChild(_workshop);
|
||||
AddChild(_workshopDetails);
|
||||
AddChild(_orderRow);
|
||||
AddChild(PanelKit.Separator());
|
||||
AddChild(UiTheme.Text(T("Rinnovo della flotta"), 14, bold: true));
|
||||
AddChild(_fleet);
|
||||
_status.AutowrapMode = TextServer.AutowrapMode.WordSmart;
|
||||
AddChild(_status);
|
||||
|
||||
@@ -113,10 +125,26 @@ public partial class MaintenancePanel : VBoxContainer
|
||||
if (_depot >= 0) _session.Send(new RequestDetail { Kind = DetailKind.Workshop, Target = _depot });
|
||||
}
|
||||
var w = _session.World;
|
||||
// quadro della flotta: all'apertura e a ogni nuovo giorno; di nuovo dopo 5 s se non arriva
|
||||
_sinceFleet += delta;
|
||||
long today = Fmt.Today(w);
|
||||
if (today != _fleetDay || (w.Fleet is null && _sinceFleet > 5)) RequestFleet(today);
|
||||
if (w.EntityVersion != _entityVersion || w.DetailVersion != _detailVersion) Refresh();
|
||||
}
|
||||
|
||||
private void Result(CommandResultMessage r) => _status.Text = r.Message;
|
||||
private void RequestFleet(long day)
|
||||
{
|
||||
_fleetDay = day;
|
||||
_sinceFleet = 0;
|
||||
_session.Send(new RequestDetail { Kind = DetailKind.Fleet, Target = 0 });
|
||||
}
|
||||
|
||||
private void Result(CommandResultMessage r)
|
||||
{
|
||||
_status.Text = r.Message;
|
||||
// un rinnovo prenotato o completato cambia il quadro della flotta
|
||||
RequestFleet(Fmt.Today(_session.World));
|
||||
}
|
||||
|
||||
private void Refresh()
|
||||
{
|
||||
@@ -160,6 +188,7 @@ public partial class MaintenancePanel : VBoxContainer
|
||||
|
||||
BuildCard();
|
||||
BuildWorkshop();
|
||||
if (!_fleetBuilt || !ReferenceEquals(w.Fleet, _fleetShown)) BuildFleet();
|
||||
}
|
||||
|
||||
private string DueText(TrainInfo t)
|
||||
@@ -212,6 +241,12 @@ public partial class MaintenancePanel : VBoxContainer
|
||||
{
|
||||
var def = w.Data.Vehicles.FirstOrDefault(d => d.Id == v.Type);
|
||||
_cardDetails.AddChild(UiTheme.Text($"{def?.NameIt ?? v.Type} #{v.Vehicle} · {v.OdometerKm / 1000:0.#} {T("mila km")} · {v.AgeYears:0.#} {T("anni")}", 13, bold: true));
|
||||
if (w.Fleet?.Vehicles.FirstOrDefault(f => f.Vehicle == v.Vehicle) is { } info)
|
||||
{
|
||||
var value = UiTheme.Text(VehicleOutlook(info), 12, info.Superseded ? Palette.Amber : Palette.TextSecondary);
|
||||
value.AutowrapMode = TextServer.AutowrapMode.WordSmart;
|
||||
_cardDetails.AddChild(value);
|
||||
}
|
||||
foreach (var c in v.Components)
|
||||
{
|
||||
var row = PanelKit.Row(6);
|
||||
@@ -261,8 +296,98 @@ public partial class MaintenancePanel : VBoxContainer
|
||||
actions.AddChild(b);
|
||||
}
|
||||
_cardControls.AddChild(actions);
|
||||
// rinnovo: l'intervento con effetto «renew» dei dati, vende i veicoli superati e compra i successori
|
||||
if (w.Data.Maintenance.Interventions.FirstOrDefault(i => i.Effect == InterventionEffect.Renew) is { } renewal)
|
||||
{
|
||||
var renew = new Button { Text = renewal.NameIt };
|
||||
renew.Pressed += () => _session.Command(new ScheduleServiceCommand(new TrainId(_train), renewal.Id), Result);
|
||||
_cardControls.AddChild(renew);
|
||||
}
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------ rinnovo della flotta
|
||||
|
||||
/// <summary>Riga di obsolescenza di un veicolo: superato, successore con prestazioni e prezzo, valori, costo di manutenzione.</summary>
|
||||
private string VehicleOutlook(FleetVehicleInfo v)
|
||||
{
|
||||
var parts = new List<string>();
|
||||
if (v.Superseded)
|
||||
{
|
||||
parts.Add(string.Format(T("superato dal {0}"), v.SupersededYear));
|
||||
var next = _session.World.Data.Vehicles.FirstOrDefault(d => d.Id == v.Successor);
|
||||
if (next is not null)
|
||||
parts.Add(string.Format(T("successore {0} ({1} kW, {2} km/h, {3})"), next.NameIt, next.PowerKw, next.MaxSpeedKmh, new Money(next.Price)));
|
||||
}
|
||||
if (!v.InProduction) parts.Add(T("fuori produzione"));
|
||||
parts.Add(string.Format(T("valore {0}"), v.BookValue));
|
||||
parts.Add(string.Format(T("rivendita {0}"), v.Resale));
|
||||
if (v.MaintenanceFactor > 1.001f) parts.Add(string.Format(T("manutenzione ×{0:0.##}"), v.MaintenanceFactor));
|
||||
return string.Join(" · ", parts);
|
||||
}
|
||||
|
||||
private void BuildFleet()
|
||||
{
|
||||
foreach (var c in _fleet.GetChildren()) c.QueueFree();
|
||||
var w = _session.World;
|
||||
var report = w.Fleet;
|
||||
_fleetShown = report;
|
||||
_fleetBuilt = true;
|
||||
if (report is null)
|
||||
{
|
||||
_fleet.AddChild(UiTheme.Text(T("Quadro della flotta in arrivo dal server…"), 13, Palette.TextSecondary));
|
||||
return;
|
||||
}
|
||||
_fleet.AddChild(PanelKit.Pair(T("Era"), PanelKit.Value(EraName(report.Era))));
|
||||
if (report.NextEra.Length > 0)
|
||||
_fleet.AddChild(PanelKit.Pair(T("Prossima era"), PanelKit.Value($"{EraName(report.NextEra)} · {report.NextEraYear}")));
|
||||
_fleet.AddChild(PanelKit.Pair(T("Valore della flotta"), PanelKit.Value(report.BookValueTotal.ToString())));
|
||||
var superseded = report.Vehicles.Where(v => v.Superseded).ToList();
|
||||
if (superseded.Count == 0)
|
||||
{
|
||||
_fleet.AddChild(UiTheme.Text(T("Nessun veicolo superato"), 13, Palette.TextSecondary));
|
||||
return;
|
||||
}
|
||||
foreach (var v in superseded.Take(8))
|
||||
{
|
||||
var def = w.Data.Vehicles.FirstOrDefault(d => d.Id == v.Type);
|
||||
string where = v.Train >= 0 && w.Trains.TryGetValue(v.Train, out var t) ? t.Name
|
||||
: v.Depot >= 0 && w.Depots.TryGetValue(v.Depot, out var d) ? d.Name : "";
|
||||
_fleet.AddChild(UiTheme.Text($"{def?.NameIt ?? v.Type} #{v.Vehicle} · {where} · {v.AgeYears:0.#}/{v.LifeYears} {T("anni")}", 13, bold: true));
|
||||
var line = UiTheme.Text(VehicleOutlook(v), 12, Palette.Amber);
|
||||
line.AutowrapMode = TextServer.AutowrapMode.WordSmart;
|
||||
_fleet.AddChild(line);
|
||||
}
|
||||
if (superseded.Count > 8)
|
||||
_fleet.AddChild(UiTheme.Text(string.Format(T("e altri {0} veicoli superati"), superseded.Count - 8), 12, Palette.TextSecondary));
|
||||
foreach (var r in report.Trains)
|
||||
{
|
||||
string name = w.Trains.TryGetValue(r.Train, out var t) ? t.Name : $"#{r.Train}";
|
||||
var row = PanelKit.Row(6);
|
||||
var text = UiTheme.Text(string.Format(T("{0}: {1} veicoli da rinnovare, spesa netta {2}"), name, r.Vehicles, r.NetCost), 13,
|
||||
r.Affordable ? Palette.Text : Palette.Danger);
|
||||
text.SizeFlagsHorizontal = SizeFlags.ExpandFill;
|
||||
text.AutowrapMode = TextServer.AutowrapMode.WordSmart;
|
||||
row.AddChild(text);
|
||||
if (r.Booked)
|
||||
{
|
||||
// rinnovo già prenotato: niente pulsante, ripremerlo rifarebbe la prenotazione
|
||||
row.AddChild(UiTheme.Text(T("rinnovo prenotato"), 13, Palette.TextSecondary));
|
||||
}
|
||||
else
|
||||
{
|
||||
int train = r.Train;
|
||||
string intervention = report.RenewalIntervention;
|
||||
var button = new Button { Text = T("Rinnova") };
|
||||
button.Pressed += () => _session.Command(new ScheduleServiceCommand(new TrainId(train), intervention), Result);
|
||||
row.AddChild(button);
|
||||
}
|
||||
_fleet.AddChild(row);
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>Nome italiano dell'era dal suo id in eras.json (il quadro della flotta manda l'id).</summary>
|
||||
private string EraName(string id) => _session.World.Data.Eras.Eras.FirstOrDefault(e => e.Id == id)?.NameIt ?? id;
|
||||
|
||||
// ------------------------------------------------------------------ registro officina
|
||||
|
||||
private void BuildWorkshop()
|
||||
|
||||
@@ -11,8 +11,11 @@ using static RailEnterprise.Client.App.Localization;
|
||||
namespace RailEnterprise.Client.Panels;
|
||||
|
||||
/// <summary>
|
||||
/// Treni: acquisto dei veicoli in un deposito, composizione, assegnazione alle linee, rientro.
|
||||
/// Ogni azione è un comando; la lista si aggiorna con i delta del server.
|
||||
/// Treni: acquisto dei veicoli in un deposito, composizione, assegnazione alle linee, rientro, vendita
|
||||
/// dei veicoli liberi e rinnovo dei treni con veicoli superati. Ogni azione è un comando; la lista si
|
||||
/// aggiorna con i delta del server. Catalogo, obsolescenza, successori e valori di rivendita vengono dal
|
||||
/// quadro della flotta (FleetReport, ADR 0020), chiesto all'apertura, a ogni nuovo giorno e dopo i comandi:
|
||||
/// il pannello non calcola nulla.
|
||||
/// </summary>
|
||||
public partial class TrainsPanel : VBoxContainer
|
||||
{
|
||||
@@ -20,10 +23,12 @@ public partial class TrainsPanel : VBoxContainer
|
||||
private readonly OptionButton _depot = new();
|
||||
private readonly OptionButton _vehicle = new();
|
||||
private readonly SpinBox _count = new() { MinValue = 1, MaxValue = 12, Value = 1 };
|
||||
private readonly Label _modelInfo = UiTheme.Text("", 13, Palette.TextSecondary);
|
||||
private readonly ItemList _inDepot = new() { SelectMode = ItemList.SelectModeEnum.Multi, CustomMinimumSize = new Vector2(0, 120) };
|
||||
private readonly LineEdit _name = new() { PlaceholderText = T("Nome del treno") };
|
||||
private readonly ItemList _trains = new() { CustomMinimumSize = new Vector2(0, 140) };
|
||||
private readonly OptionButton _line = new();
|
||||
private readonly Label _renewInfo = UiTheme.Text("", 13, Palette.TextSecondary);
|
||||
private readonly Label _status = UiTheme.Text("", 13, Palette.TextSecondary);
|
||||
private readonly List<int> _depotIds = [];
|
||||
private readonly List<VehicleDef> _catalog = [];
|
||||
@@ -31,6 +36,9 @@ public partial class TrainsPanel : VBoxContainer
|
||||
private readonly List<int> _trainIds = [];
|
||||
private readonly List<int> _lineIds = [];
|
||||
private int _version = -1;
|
||||
private FleetReport? _fleetShown;
|
||||
private long _requestedDay = long.MinValue;
|
||||
private double _sinceRequest = double.MaxValue;
|
||||
|
||||
public event Action<int>? TrainSelected;
|
||||
|
||||
@@ -46,6 +54,8 @@ public partial class TrainsPanel : VBoxContainer
|
||||
buy.AddChild(_vehicle);
|
||||
buy.AddChild(_count);
|
||||
AddChild(buy);
|
||||
_modelInfo.AutowrapMode = TextServer.AutowrapMode.WordSmart;
|
||||
AddChild(_modelInfo);
|
||||
var buyButton = UiTheme.Primary(T("Compra veicoli"));
|
||||
buyButton.Pressed += Buy;
|
||||
AddChild(buyButton);
|
||||
@@ -57,6 +67,9 @@ public partial class TrainsPanel : VBoxContainer
|
||||
var composeButton = new Button { Text = T("Componi") };
|
||||
composeButton.Pressed += Compose;
|
||||
compose.AddChild(composeButton);
|
||||
var sellButton = new Button { Text = T("Vendi") };
|
||||
sellButton.Pressed += Sell;
|
||||
compose.AddChild(sellButton);
|
||||
AddChild(compose);
|
||||
AddChild(PanelKit.Separator());
|
||||
AddChild(UiTheme.Text(T("Treni della compagnia"), 14, bold: true));
|
||||
@@ -71,15 +84,38 @@ public partial class TrainsPanel : VBoxContainer
|
||||
var home = new Button { Text = T("Manda al deposito") };
|
||||
home.Pressed += SendHome;
|
||||
AddChild(home);
|
||||
var renew = new Button { Text = T("Rinnova i veicoli superati") };
|
||||
renew.Pressed += Renew;
|
||||
AddChild(renew);
|
||||
_renewInfo.AutowrapMode = TextServer.AutowrapMode.WordSmart;
|
||||
AddChild(_renewInfo);
|
||||
_status.AutowrapMode = TextServer.AutowrapMode.WordSmart;
|
||||
AddChild(_status);
|
||||
_depot.ItemSelected += _ => Refresh(force: true);
|
||||
_trains.ItemSelected += i => TrainSelected?.Invoke(_trainIds[(int)i]);
|
||||
_vehicle.ItemSelected += _ => ShowModel();
|
||||
_trains.ItemSelected += i =>
|
||||
{
|
||||
TrainSelected?.Invoke(_trainIds[(int)i]);
|
||||
ShowRenewal();
|
||||
};
|
||||
}
|
||||
|
||||
public override void _Process(double delta)
|
||||
{
|
||||
if (_session.World.EntityVersion != _version) Refresh(force: false);
|
||||
var w = _session.World;
|
||||
_sinceRequest += delta;
|
||||
// quadro della flotta: all'apertura e a ogni nuovo giorno; di nuovo dopo 5 s se non arriva
|
||||
long today = Fmt.Today(w);
|
||||
if (today != _requestedDay || (w.Fleet is null && _sinceRequest > 5)) RequestFleet(today);
|
||||
bool fleetChanged = !ReferenceEquals(w.Fleet, _fleetShown);
|
||||
if (w.EntityVersion != _version || fleetChanged) Refresh(force: fleetChanged);
|
||||
}
|
||||
|
||||
private void RequestFleet(long day)
|
||||
{
|
||||
_requestedDay = day;
|
||||
_sinceRequest = 0;
|
||||
_session.Send(new RequestDetail { Kind = DetailKind.Fleet, Target = 0 });
|
||||
}
|
||||
|
||||
private int Company => _session.World.Summary?.CompanyId ?? 0;
|
||||
@@ -87,7 +123,9 @@ public partial class TrainsPanel : VBoxContainer
|
||||
private void Refresh(bool force)
|
||||
{
|
||||
var w = _session.World;
|
||||
var fleet = w.Fleet;
|
||||
_version = w.EntityVersion;
|
||||
_fleetShown = fleet;
|
||||
int selectedDepot = _depot.Selected >= 0 && _depot.Selected < _depotIds.Count ? _depotIds[_depot.Selected] : -1;
|
||||
_depotIds.Clear();
|
||||
_depot.Clear();
|
||||
@@ -101,16 +139,33 @@ public partial class TrainsPanel : VBoxContainer
|
||||
|
||||
if (_catalog.Count == 0 || force)
|
||||
{
|
||||
int keep = _vehicle.Selected;
|
||||
string? keep = _vehicle.Selected >= 0 && _vehicle.Selected < _catalog.Count ? _catalog[_vehicle.Selected].Id : null;
|
||||
_catalog.Clear();
|
||||
_vehicle.Clear();
|
||||
foreach (var def in w.Data.Vehicles.Where(v => v.EraFrom <= w.Year && (v.EraTo is null || v.EraTo >= w.Year)))
|
||||
if (fleet is not null)
|
||||
{
|
||||
_catalog.Add(def);
|
||||
_vehicle.AddItem($"{def.NameIt} — {new Money(def.Price)}");
|
||||
// catalogo del server: solo i modelli in produzione, i superati segnati con il successore
|
||||
foreach (var m in fleet.Models)
|
||||
{
|
||||
if (Def(m.Type) is not { } def) continue;
|
||||
_catalog.Add(def);
|
||||
string mark = m.Superseded ? $" · {T("superato")}" + (m.Successor.Length > 0 ? $" → {Def(m.Successor)?.NameIt ?? m.Successor}" : "") : "";
|
||||
_vehicle.AddItem($"{def.NameIt} — {new Money(def.Price)}{mark}");
|
||||
}
|
||||
}
|
||||
_vehicle.Selected = keep >= 0 && keep < _catalog.Count ? keep : 0;
|
||||
else
|
||||
{
|
||||
// in attesa del quadro del server: i modelli dell'anno, senza segni
|
||||
foreach (var def in w.Data.Vehicles.Where(v => v.EraFrom <= w.Year && (v.EraTo is null || v.EraTo >= w.Year)))
|
||||
{
|
||||
_catalog.Add(def);
|
||||
_vehicle.AddItem($"{def.NameIt} — {new Money(def.Price)}");
|
||||
}
|
||||
}
|
||||
int index = keep is null ? -1 : _catalog.FindIndex(d => d.Id == keep);
|
||||
_vehicle.Selected = index >= 0 ? index : _catalog.Count > 0 ? 0 : -1;
|
||||
}
|
||||
ShowModel();
|
||||
|
||||
int depot = _depot.Selected >= 0 ? _depotIds[_depot.Selected] : -1;
|
||||
_vehicleIds.Clear();
|
||||
@@ -118,18 +173,25 @@ public partial class TrainsPanel : VBoxContainer
|
||||
foreach (var v in w.Vehicles.Values.Where(v => v.Owner == Company && v.Depot == depot && v.Train < 0).OrderBy(v => v.Id))
|
||||
{
|
||||
_vehicleIds.Add(v.Id);
|
||||
var def = w.Data.Vehicles.FirstOrDefault(d => d.Id == v.Type);
|
||||
_inDepot.AddItem($"{def?.NameIt ?? v.Type} #{v.Id}");
|
||||
var info = fleet?.Vehicles.FirstOrDefault(x => x.Vehicle == v.Id);
|
||||
string extra = info is null
|
||||
? ""
|
||||
: (info.Superseded ? $" · {T("superato")}" : "") + " · " + string.Format(T("rivendita {0}"), info.Resale);
|
||||
_inDepot.AddItem($"{Def(v.Type)?.NameIt ?? v.Type} #{v.Id}{extra}");
|
||||
if (info is { Superseded: true }) _inDepot.SetItemCustomFgColor(_inDepot.ItemCount - 1, Palette.Amber);
|
||||
}
|
||||
|
||||
var selectedTrain = _trains.GetSelectedItems() is { Length: > 0 } sel ? _trainIds[sel[0]] : -1;
|
||||
var selectedTrain = SelectedTrain;
|
||||
_trainIds.Clear();
|
||||
_trains.Clear();
|
||||
foreach (var t in w.Trains.Values.Where(t => t.Owner == Company).OrderBy(t => t.Id))
|
||||
{
|
||||
_trainIds.Add(t.Id);
|
||||
string line = t.Line >= 0 && w.Lines.TryGetValue(t.Line, out var l) ? l.Name : T("senza linea");
|
||||
_trains.AddItem($"{t.Name} · {StateName((TrainState)t.State)} · {line}");
|
||||
var renewal = fleet?.Trains.FirstOrDefault(r => r.Train == t.Id);
|
||||
string mark = renewal is null ? "" : " · " + (renewal.Booked ? T("rinnovo prenotato") : T("da rinnovare"));
|
||||
_trains.AddItem($"{t.Name} · {StateName((TrainState)t.State)} · {line}{mark}");
|
||||
if (renewal is { Booked: false }) _trains.SetItemCustomFgColor(_trains.ItemCount - 1, Palette.Amber);
|
||||
}
|
||||
int ti = _trainIds.IndexOf(selectedTrain);
|
||||
if (ti >= 0) _trains.Select(ti);
|
||||
@@ -146,6 +208,40 @@ public partial class TrainsPanel : VBoxContainer
|
||||
}
|
||||
int li = _lineIds.IndexOf(selectedLine);
|
||||
_line.Selected = li >= 0 ? li : Math.Min(1, _lineIds.Count - 1);
|
||||
ShowRenewal();
|
||||
}
|
||||
|
||||
private VehicleDef? Def(string id) => _session.World.Data.Vehicles.FirstOrDefault(v => v.Id == id);
|
||||
|
||||
/// <summary>Modello scelto nel catalogo: superato o no, successore con prestazioni e prezzo, ultimo anno di produzione.</summary>
|
||||
private void ShowModel()
|
||||
{
|
||||
var fleet = _session.World.Fleet;
|
||||
if (fleet is null || _vehicle.Selected < 0 || _vehicle.Selected >= _catalog.Count) { _modelInfo.Text = ""; return; }
|
||||
var model = fleet.Models.FirstOrDefault(m => m.Type == _catalog[_vehicle.Selected].Id);
|
||||
if (model is null) { _modelInfo.Text = ""; return; }
|
||||
var parts = new List<string>();
|
||||
if (model.Superseded)
|
||||
{
|
||||
var next = Def(model.Successor);
|
||||
parts.Add(next is null
|
||||
? string.Format(T("Superato dal {0}."), model.SupersededYear)
|
||||
: string.Format(T("Superato dal {0}: successore {1} ({2} kW, {3} km/h, {4})."),
|
||||
model.SupersededYear, next.NameIt, next.PowerKw, next.MaxSpeedKmh, new Money(next.Price)));
|
||||
}
|
||||
if (model.LastYear > 0) parts.Add(string.Format(T("In produzione fino al {0}."), model.LastYear));
|
||||
_modelInfo.Text = string.Join(" ", parts);
|
||||
}
|
||||
|
||||
/// <summary>Rinnovo del treno scelto: veicoli superati e spesa netta calcolati dal server.</summary>
|
||||
private void ShowRenewal()
|
||||
{
|
||||
int train = SelectedTrain;
|
||||
var renewal = train >= 0 ? _session.World.Fleet?.Trains.FirstOrDefault(r => r.Train == train) : null;
|
||||
_renewInfo.Text = renewal is null
|
||||
? ""
|
||||
: string.Format(T("Rinnovo: {0} veicoli superati, spesa netta {1} dopo le rivendite."), renewal.Vehicles, renewal.NetCost)
|
||||
+ (renewal.Booked ? " " + T("Rinnovo già prenotato.") : renewal.Affordable ? "" : " " + T("Cassa insufficiente."));
|
||||
}
|
||||
|
||||
public static string StateName(TrainState s) => s switch
|
||||
@@ -160,7 +256,12 @@ public partial class TrainsPanel : VBoxContainer
|
||||
_ => s.ToString(),
|
||||
};
|
||||
|
||||
private void Result(CommandResultMessage r) => _status.Text = r.Message;
|
||||
private void Result(CommandResultMessage r)
|
||||
{
|
||||
_status.Text = r.Message;
|
||||
// acquisti, vendite e rinnovi cambiano il quadro della flotta
|
||||
RequestFleet(Fmt.Today(_session.World));
|
||||
}
|
||||
|
||||
private void Buy()
|
||||
{
|
||||
@@ -177,7 +278,14 @@ public partial class TrainsPanel : VBoxContainer
|
||||
_session.Command(new ComposeTrainCommand(new DepotId(_depotIds[_depot.Selected]), selected, name), Result);
|
||||
}
|
||||
|
||||
private int SelectedTrain => _trains.GetSelectedItems() is { Length: > 0 } sel ? _trainIds[sel[0]] : -1;
|
||||
private void Sell()
|
||||
{
|
||||
var selected = _inDepot.GetSelectedItems().OrderBy(i => i).Select(i => _vehicleIds[i]).ToList();
|
||||
if (selected.Count == 0) { _status.Text = T("Seleziona i veicoli da vendere"); return; }
|
||||
foreach (int id in selected) _session.Command(new SellVehicleCommand(new VehicleId(id)), Result);
|
||||
}
|
||||
|
||||
private int SelectedTrain => _trains.GetSelectedItems() is { Length: > 0 } sel && sel[0] < _trainIds.Count ? _trainIds[sel[0]] : -1;
|
||||
|
||||
private void Assign()
|
||||
{
|
||||
@@ -192,4 +300,13 @@ public partial class TrainsPanel : VBoxContainer
|
||||
if (train < 0 || _depot.Selected < 0) { _status.Text = T("Seleziona un treno e un deposito"); return; }
|
||||
_session.Command(new SendToDepotCommand(new TrainId(train), new DepotId(_depotIds[_depot.Selected])), Result);
|
||||
}
|
||||
|
||||
private void Renew()
|
||||
{
|
||||
int train = SelectedTrain;
|
||||
if (train < 0) { _status.Text = T("Seleziona un treno"); return; }
|
||||
string intervention = _session.World.Fleet?.RenewalIntervention ?? "";
|
||||
if (intervention.Length == 0) { _status.Text = T("Quadro della flotta in arrivo dal server…"); return; }
|
||||
_session.Command(new ScheduleServiceCommand(new TrainId(train), intervention), Result);
|
||||
}
|
||||
}
|
||||
@@ -57,6 +57,12 @@
|
||||
"industryMaxCashShare": 0.25,
|
||||
"industryMinMargin": 0.1
|
||||
},
|
||||
"renewal": {
|
||||
"minSupersededYears": 3,
|
||||
"minAgeShareOfLife": 0.5,
|
||||
"cashReserveMultiple": 2.0,
|
||||
"maxTrainsPerMonth": 1
|
||||
},
|
||||
"personalities": [
|
||||
{ "id": "expansive", "name_it": "Espansiva", "roiThreshold": 0.08, "loanShareOfCredit": 0.8, "targetsPlayer": false, "buysShares": false, "maintenancePolicy": "standard" },
|
||||
{ "id": "prudent", "name_it": "Prudente", "roiThreshold": 0.15, "loanShareOfCredit": 0.3, "targetsPlayer": false, "buysShares": false, "maintenancePolicy": "standard" },
|
||||
|
||||
@@ -55,7 +55,8 @@
|
||||
{ "id": "overhaul", "name_it": "Revisione generale", "days": 20, "costShare": 0.12, "spareParts": 5, "effect": "overhaul" },
|
||||
{ "id": "repair_minor", "name_it": "Riparazione dopo guasto lieve", "days": 2, "costShare": 0.03, "spareParts": 1, "effect": "repair", "restoreTo": 80 },
|
||||
{ "id": "repair_major", "name_it": "Riparazione dopo guasto grave", "days": 7, "costShare": 0.08, "spareParts": 3, "effect": "repair", "restoreTo": 90 },
|
||||
{ "id": "repair_catastrophic", "name_it": "Ricostruzione dopo deragliamento", "days": 30, "costShare": 0.3, "spareParts": 8, "effect": "replace" }
|
||||
{ "id": "repair_catastrophic", "name_it": "Ricostruzione dopo deragliamento", "days": 30, "costShare": 0.3, "spareParts": 8, "effect": "replace" },
|
||||
{ "id": "renewal", "name_it": "Rinnovo dei veicoli superati", "days": 4, "costShare": 0.005, "spareParts": 0, "effect": "renew" }
|
||||
],
|
||||
"inspection": { "brakesTo": 100, "othersPlus": 10, "hazardFactor": 0.5, "hazardDays": 30 },
|
||||
"service": { "plus": 40 },
|
||||
|
||||
@@ -91,6 +91,34 @@
|
||||
},
|
||||
"minItems": 1
|
||||
},
|
||||
"renewal": {
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"minSupersededYears": {
|
||||
"type": "number",
|
||||
"minimum": 0
|
||||
},
|
||||
"minAgeShareOfLife": {
|
||||
"type": "number",
|
||||
"minimum": 0
|
||||
},
|
||||
"cashReserveMultiple": {
|
||||
"type": "number",
|
||||
"minimum": 0
|
||||
},
|
||||
"maxTrainsPerMonth": {
|
||||
"type": "integer",
|
||||
"minimum": 0
|
||||
}
|
||||
},
|
||||
"required": [
|
||||
"minSupersededYears",
|
||||
"minAgeShareOfLife",
|
||||
"cashReserveMultiple",
|
||||
"maxTrainsPerMonth"
|
||||
],
|
||||
"additionalProperties": false
|
||||
},
|
||||
"market": {
|
||||
"type": "object",
|
||||
"additionalProperties": {
|
||||
@@ -108,7 +136,8 @@
|
||||
"personalities",
|
||||
"companyNames",
|
||||
"colors",
|
||||
"market"
|
||||
"market",
|
||||
"renewal"
|
||||
],
|
||||
"additionalProperties": false
|
||||
}
|
||||
@@ -160,7 +160,8 @@
|
||||
"service",
|
||||
"overhaul",
|
||||
"repair",
|
||||
"replace"
|
||||
"replace",
|
||||
"renew"
|
||||
]
|
||||
},
|
||||
"restoreTo": {
|
||||
|
||||
@@ -10,6 +10,32 @@
|
||||
"type": "integer",
|
||||
"minimum": 1
|
||||
},
|
||||
"obsolescence": {
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"immediateValueLoss": {
|
||||
"type": "number",
|
||||
"minimum": 0,
|
||||
"maximum": 0.9
|
||||
},
|
||||
"depreciationSpeed": {
|
||||
"type": "number",
|
||||
"minimum": 1,
|
||||
"maximum": 10
|
||||
},
|
||||
"maintenanceCostFactor": {
|
||||
"type": "number",
|
||||
"minimum": 1,
|
||||
"maximum": 10
|
||||
}
|
||||
},
|
||||
"required": [
|
||||
"immediateValueLoss",
|
||||
"depreciationSpeed",
|
||||
"maintenanceCostFactor"
|
||||
],
|
||||
"additionalProperties": false
|
||||
},
|
||||
"vehicles": {
|
||||
"type": "array",
|
||||
"items": {
|
||||
@@ -45,6 +71,10 @@
|
||||
"minimum": 1800,
|
||||
"maximum": 2300
|
||||
},
|
||||
"successor": {
|
||||
"type": "string",
|
||||
"pattern": "^[a-z][a-z0-9_]*$"
|
||||
},
|
||||
"powerKw": {
|
||||
"type": "number",
|
||||
"minimum": 0
|
||||
@@ -152,6 +182,7 @@
|
||||
},
|
||||
"required": [
|
||||
"version",
|
||||
"obsolescence",
|
||||
"vehicles"
|
||||
],
|
||||
"additionalProperties": false
|
||||
|
||||
+6
-5
@@ -1,17 +1,18 @@
|
||||
{
|
||||
"$schema": "schema/vehicles.schema.json",
|
||||
"version": 1,
|
||||
"obsolescence": { "immediateValueLoss": 0.15, "depreciationSpeed": 2.0, "maintenanceCostFactor": 1.5 },
|
||||
"vehicles": [
|
||||
{ "id": "loco_steam_1850", "kind": "locomotive", "name_it": "Ardita 2-6-0", "name_en": "Ardita 2-6-0",
|
||||
"eraFrom": 1850, "eraTo": 1905, "powerKw": 300, "tractiveEffortKn": 70, "maxSpeedKmh": 60, "massT": 38, "lengthM": 16,
|
||||
"eraFrom": 1850, "eraTo": 1905, "successor": "loco_steam_1878", "powerKw": 300, "tractiveEffortKn": 70, "maxSpeedKmh": 60, "massT": 38, "lengthM": 16,
|
||||
"price": 1800000, "runningCostPerYear": 240000, "lifeYears": 25, "traction": "steam",
|
||||
"components": { "engine": 1.0, "wheelsets": 0.8, "brakes": 1.0, "electrics": 0.6 } },
|
||||
{ "id": "loco_steam_1878", "kind": "locomotive", "name_it": "Vittoria 2-8-0", "name_en": "Vittoria 2-8-0",
|
||||
"eraFrom": 1878, "eraTo": 1935, "powerKw": 650, "tractiveEffortKn": 110, "maxSpeedKmh": 70, "massT": 62, "lengthM": 18,
|
||||
"eraFrom": 1878, "eraTo": 1935, "successor": "loco_steam_1902", "powerKw": 650, "tractiveEffortKn": 110, "maxSpeedKmh": 70, "massT": 62, "lengthM": 18,
|
||||
"price": 3200000, "runningCostPerYear": 380000, "lifeYears": 30, "traction": "steam",
|
||||
"components": { "engine": 1.0, "wheelsets": 0.9, "brakes": 1.0, "electrics": 0.6 } },
|
||||
{ "id": "loco_steam_1902", "kind": "locomotive", "name_it": "Freccia 4-6-2", "name_en": "Freccia 4-6-2",
|
||||
"eraFrom": 1902, "eraTo": 1945, "powerKw": 1150, "tractiveEffortKn": 95, "maxSpeedKmh": 110, "massT": 88, "lengthM": 21,
|
||||
"eraFrom": 1902, "eraTo": 1945, "successor": "loco_diesel_1925", "powerKw": 1150, "tractiveEffortKn": 95, "maxSpeedKmh": 110, "massT": 88, "lengthM": 21,
|
||||
"price": 5600000, "runningCostPerYear": 560000, "lifeYears": 30, "traction": "steam",
|
||||
"components": { "engine": 1.1, "wheelsets": 1.0, "brakes": 1.0, "electrics": 0.6 } },
|
||||
{ "id": "loco_diesel_1925", "kind": "locomotive", "name_it": "Aquila D1", "name_en": "Aquila D1",
|
||||
@@ -19,7 +20,7 @@
|
||||
"price": 7500000, "runningCostPerYear": 420000, "lifeYears": 30, "traction": "diesel",
|
||||
"components": { "engine": 0.9, "wheelsets": 0.8, "brakes": 0.9, "electrics": 0.9 } },
|
||||
{ "id": "loco_electric_1950", "kind": "locomotive", "name_it": "Saetta E50", "name_en": "Saetta E50",
|
||||
"eraFrom": 1950, "eraTo": 2010, "powerKw": 3200, "tractiveEffortKn": 260, "maxSpeedKmh": 160, "massT": 84, "lengthM": 18,
|
||||
"eraFrom": 1950, "eraTo": 2010, "successor": "loco_highspeed_1990", "powerKw": 3200, "tractiveEffortKn": 260, "maxSpeedKmh": 160, "massT": 84, "lengthM": 18,
|
||||
"price": 14000000, "runningCostPerYear": 520000, "lifeYears": 35, "traction": "electric",
|
||||
"components": { "engine": 0.7, "wheelsets": 0.9, "brakes": 0.9, "electrics": 1.2 } },
|
||||
{ "id": "loco_highspeed_1990", "kind": "locomotive", "name_it": "Lampo AV", "name_en": "Lampo HS",
|
||||
@@ -43,7 +44,7 @@
|
||||
"capacity": 16, "wagonType": "box", "goods": [ "food", "goods", "tools", "spare_parts", "livestock", "grain" ],
|
||||
"components": { "axles": 1.0, "brakes": 1.0, "body": 1.0 } },
|
||||
{ "id": "coach_worker", "kind": "coach", "name_it": "Carrozza operai", "name_en": "Workers' coach",
|
||||
"eraFrom": 1850, "maxSpeedKmh": 100, "massT": 18, "lengthM": 14, "price": 220000, "runningCostPerYear": 20000, "lifeYears": 40,
|
||||
"eraFrom": 1850, "successor": "coach_modern", "maxSpeedKmh": 100, "massT": 18, "lengthM": 14, "price": 220000, "runningCostPerYear": 20000, "lifeYears": 40,
|
||||
"paxCapacity": 60, "class": "worker",
|
||||
"components": { "axles": 1.0, "brakes": 1.0, "body": 1.0 } },
|
||||
{ "id": "coach_staff", "kind": "coach", "name_it": "Carrozza tecnici", "name_en": "Staff coach",
|
||||
|
||||
@@ -40,7 +40,7 @@ Regole:
|
||||
```
|
||||
Clock → Commands → Construction → Trains → Signals → Stations → Maintenance (treni)
|
||||
→ Demand (giornaliero) → Commuting → Industries → IndustryMaintenance → Towns → Market
|
||||
→ Finance → StockMarket → AiAgents (mensile) → Events → Contracts → Hash (giornaliero)
|
||||
→ Finance → StockMarket → AiAgents (mensile) → Events → Eras (annuale) → Contracts → Hash (giornaliero)
|
||||
```
|
||||
|
||||
Sistemi implementati (F1–F5), nella loro posizione:
|
||||
@@ -64,6 +64,7 @@ Sistemi implementati (F1–F5), nella loro posizione:
|
||||
| `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») |
|
||||
| `EraSystem` | anno | novità tecnologiche (F6, ADR 0020): il 1° gennaio, dai dati, la notizia dell'era che inizia, di trazioni, veicoli, ponti, gallerie, binari, segnali, elettrificazione, merci e industrie introdotti, dei modelli superati e di quelli fuori produzione (`EventKind.Technology`), annotata nella Cronaca; senza stato |
|
||||
| `HashSystem` | giorno | hash dello stato dinamico |
|
||||
|
||||
- Ogni sistema implementa `ISimSystem.Step(WorldContext ctx)`; i sistemi giornalieri o mensili controllano `ctx.IsNewDay` / `ctx.IsNewMonth` e ritornano subito negli altri tick: nei 239 tick su 240 lavora solo `TrainSystem`.
|
||||
@@ -92,7 +93,7 @@ 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. `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à.
|
||||
- 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à. `FleetOutlook` (F6, ADR 0020) è il quadro in sola lettura del rinnovo della flotta: era in corso e prossima, veicoli con età, superato, successore consigliato, valore di libro, rivendita e fattore di manutenzione, catalogo dei modelli in produzione, treni da rinnovare con la spesa netta. Produzione, obsolescenza e valore dei veicoli vengono da `Simulation.Systems.Obsolescence` (senza stato, dai dati, dal calendario e dal giorno d'acquisto): è l'unica fonte del valore per il patrimonio (`FinanceSystem.BookValues`), `SellVehicle`, il rinnovo in officina (intervento «renewal», effetto `renew`) e i costi di manutenzione dei modelli superati.
|
||||
- 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.
|
||||
|
||||
+6
-4
@@ -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, 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 |
|
||||
| 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, 10 quadro del rinnovo della flotta), `target: i32` (id del treno, del deposito, della compagnia o dell'industria; ignorato per 3, 6, 7, 8, 9 e 10). Aggiunto in F4 |
|
||||
|
||||
### Comandi (`Command.type`, payload in ordine)
|
||||
|
||||
@@ -99,7 +99,7 @@ costMultiplier: f64 }`
|
||||
| 14 | SendToDepot | `train: i32`, `depot: i32` |
|
||||
| 15 | SetReserve | `train: i32`, `reserve: bool` |
|
||||
| 16 | SetMaintenancePolicy | `scope: u8` (0 compagnia, 1 linea, 2 treno), `target: i32`, `policy: string` |
|
||||
| 17 | ScheduleService | `train: i32`, `intervention: string` |
|
||||
| 17 | ScheduleService | `train: i32`, `intervention: string` (id di `maintenance.json`; dalla F6 anche «renewal», il rinnovo dei veicoli superati: in officina si vendono e si sostituiscono con il successore consigliato, ADR 0020) |
|
||||
| 18 | OrderParts | `depot: i32`, `quantity: i32`; blocco 1 (F5): `industry: i32` (ricambi ordinati per un'industria posseduta, oltre la scorta della politica) |
|
||||
| 19 | TakeLoan | `amount: Money` |
|
||||
| 20 | RepayLoan | `loan: i32`, `amount: Money` |
|
||||
@@ -162,6 +162,7 @@ loro fase i comandi 35–38 rispondono `NotImplemented`. Il server imposta l'emi
|
||||
| 133 | SaveList | `saves: [SaveInfo]` |
|
||||
| 134 | ClimbReport | `day: i64, company: i32, foundedDay: i64, initialCapital: Money, tier: u8, nextTier: u8 (0 all'ultimo livello), tiers: [TierInfo]`; requisiti del prossimo livello: `netWorth, netWorthRequired: Money, netWorthFraction: f32, netWorthMet: bool, towns, townsRequired, townPopulation: i32, townsFraction: f32, townsMet: bool, rating, ratingRequired: string, ratingFraction: f32, ratingMet: bool, progress: f32` (media delle tre frazioni); stato patrimoniale: `assets: [AmountInfo]` (kind 0 binari e opere, 1 stazioni e depositi, 2 veicoli, 3 industrie possedute, 4 merce propria), `portfolio, cash (positiva), totalAssets, loans: Money, loansRate: f32 (medio), overdraft (scoperto), totalLiabilities, balanceNetWorth: Money` (= totalAssets − totalLiabilities = patrimonio netto del motore); conto economico: `incomeYear: i32, incomePartial: bool, income: [AmountInfo]` (kind 0 tariffe e noli, 1 altri ricavi, 2 costi operativi, 3 manutenzione, 4 interessi; con segno), `profit: Money`; prestiti: `loanList: [LoanInfo], maxLoan, loanAvailable: Money, newLoanRate: f32, loansAllowed: bool`; `history: [NetWorthPointInfo]` (fondazione, fine di ogni anno, oggi) (su richiesta, F6; ADR 0018) |
|
||||
| 135 | FinanceReport | `day: i64, company: i32, cash, netWorth, loans, overdraft: Money`; conto economico: `lines: [FinanceLineInfo]` (voci in ordine di presentazione), `columns: [IncomeColumnInfo]` (mese in corso, mesi chiusi dal più recente, anno in corso, anni chiusi dal più recente); rating: `rating: string, ratingInitial: bool, ratingMonths, revenueMonths: u8, marginNeutral: bool (margine 0 finché la finestra non è piena e ha meno di minRevenueMonths mesi con ricavi), minRevenueMonths: u8, margin, leverage: f32, leverageUnbounded: bool, marginWeight, leverageWeight, marginComponent, leverageComponent, score: f32, thresholds: [RatingThresholdInfo], nextRating: string ("" ad AAA), nextThreshold: f32, nextAlreadyMet: bool (il punteggio basta già: rating scoreRating al prossimo calcolo mensile, obiettivi a zero), scoreRating: string, marginNeeded: f32, marginReachable: bool, leverageMax: f32 (sempre finita), leverageReachable: bool, debtToRepay: Money, repayAffordable: bool (il rimborso non supera la cassa né il residuo dei prestiti; lo scoperto non si rimborsa)`; prestiti: `loanList: [FinanceLoanInfo], maxLoan, loanAvailable: Money, newLoanRate, baseRate, spread: f32, loanTermMonths: i32, loanStep: Money, loansAllowed: bool`; bancarotta: `negativeCashDays, bankruptcyDays: i32, bankrupt, receivership: bool` (su richiesta, F6; ADR 0019) |
|
||||
| 136 | FleetReport | `day: i64, company, year: i32, era, nextEra: string (id di eras.json; nextEra "" all'ultima), nextEraYear: i32 (0 all'ultima), renewalIntervention: string (id per `ScheduleService`), bookValueTotal: Money (coincide con la voce «veicoli» dello stato patrimoniale), vehicles: [FleetVehicleInfo] (veicoli non venduti della compagnia, per id), models: [VehicleModelInfo] (solo i modelli in produzione nell'anno, nell'ordine di vehicles.json), trains: [RenewalTrainInfo] (treni con veicoli da rinnovare)` (su richiesta, F6; ADR 0020) |
|
||||
|
||||
Record (ognuno chiude con `flags`):
|
||||
|
||||
@@ -182,7 +183,7 @@ Record (ognuno chiude con `flags`):
|
||||
3 guasto lieve, 4 fermo in linea, 5 rimorchiato), `reserve: bool`, `policy: u8` (255 = ereditata), `nextIntervention: string`,
|
||||
`nextDueDays: i32`, `maintenanceDepot: i32`
|
||||
- `EdgeInfo { id, owner, a, b, trackClass: u8, doubleTrack, electrified, state: u8, condition: f32, structureCondition: f32, progress: f32, samples: [(s, x, y, h, ground: f64, kind: u8, speedLimitKmh: f64)], signals: [f64] }`
|
||||
- `EventInfo { day: i64, kind: u8, severity: u8, text, entity: u8, entityIndex: i32, company: i32 }`; `kind` 10 = evento del mondo (inizio e fine, F6)
|
||||
- `EventInfo { day: i64, kind: u8, severity: u8, text, entity: u8, entityIndex: i32, company: i32 }`; `kind` 10 = evento del mondo (inizio e fine, F6), 11 = novità tecnologiche dell'anno (era che inizia, modelli introdotti, superati e fuori produzione; F6, ADR 0020)
|
||||
- `WorldEventInfo { id: i32, type: string (id di events.json), entity: u8 (1 città, 2 industria, 7 deposito), entityIndex: i32, good: i32 (−1 se nessuno), startDay: i64 (dopo `day` per un evento estratto oggi, che inizia domani), endDay: i64 (primo giorno senza l'evento: il server lo toglie quel mattino), severity: u8, effects: [f32] }`: `effects` sono i moltiplicatori nell'ordine degli effetti del tipo nel catalogo (ADR 0017)
|
||||
- `EmploymentRow { industry, jobsWorkers, jobsStaff, workersPresent: f32, staffPresent: f32, reason, sources: [EmploymentSource { town, homeStation, line, category: u8, headcount, coverage: f32 }] }`;
|
||||
blocco 1: `kind: u8` (0 industria, 1 deposito: `industry` è allora l'id del deposito), `workersReason: u8`, `staffReason: u8`
|
||||
@@ -203,6 +204,7 @@ Record (ognuno chiude con `flags`):
|
||||
- `LedgerEntry` (voce del registro, u8): 0 FreightRevenue (noli merci), 1 PassengerRevenue (biglietti), 2 Construction (costruzioni), 3 VehiclePurchase (acquisto di treni), 4 VehicleSale (vendita di treni), 5 RunningCosts (esercizio dei treni), 6 TrackMaintenance (manutenzione dei binari), 7 FleetMaintenance (manutenzione dei treni), 8 Wages (stipendi), 9 Interest (interessi), 10 LoanTaken (prestiti ricevuti), 11 LoanRepaid (prestiti rimborsati), 12 Trading (commercio in proprio), 13 IndustryPurchase (acquisto di industrie), 14 Dividends (dividendi pagati), 15 Shares (azioni), 16 Contracts (contratti), 17 Penalties (penali), 18 Other (altro), 19 Industries (industrie possedute), 20 Subsidiaries (controllate), 21 StationUpkeep (stazioni e depositi), 22 Storage (magazzini), 23 Duties (dazi), 24 DividendsReceived (dividendi incassati). Sezione: ricavi 0, 1, 12, 16, 19, 20, 24; costi 5–9, 17, 21–23; investimenti e finanziamenti gli altri (ADR 0019)
|
||||
- `FinanceLineInfo { kind: u8 (LedgerEntry), section: u8 (0 ricavi, 1 costi, 2 investimenti e finanziamenti) }`, `IncomeColumnInfo { kind: u8 (0 mese in corso, 1 mese chiuso, 2 anno in corso, 3 anno chiuso), year: i32, month: u8 (1–12, 0 per gli anni), values: [AmountInfo] (solo le voci diverse da zero, kind = LedgerEntry, con segno), profit: Money (utile operativo del motore), cashFlow: Money }`, `RatingThresholdInfo { rating: string, minScore, loanRate: f32 }`, `FinanceLoanInfo { loan: i32, principal, remaining: Money, annualRate: f32 (fisso), monthsLeft: i32, payment, nextInterest: Money, maturityDay: i64 }`
|
||||
- `HubMarketInfo { hub, kind: u8 (0 porto, 1 valico), monthlyCapacity, duty: f32, usedThisMonth, line: i32 (−1 non collegato) }`
|
||||
- `FleetVehicleInfo { vehicle: i32, type: string, train, depot: i32 (−1 se nessuno), ageYears: f32, lifeYears: i32, condition: f32 (media dei componenti, 0–1), inProduction, superseded: bool, supersededYear: i32 (0 senza successore), successor: string (consigliato, "" se non superato o senza successore in produzione), bookValue, resale: Money, maintenanceFactor: f32 }`, `VehicleModelInfo { type: string, superseded: bool, supersededYear: i32, successor: string, lastYear: i32 (ultimo anno di produzione, 0 se non previsto) }`, `RenewalTrainInfo { train, vehicles: i32, netCost: Money (successori − rivendite + lavoro, può essere negativa), affordable: bool (la cassa basta al netto degli altri rinnovi prenotati), booked: bool (rinnovo già prenotato, non ancora avviato) }`
|
||||
- `WarehouseInfo { station, capacity, incoming: i32 (merce propria in viaggio verso la stazione), goods: [WarehouseGoodInfo] }` (stazioni vive della compagnia)
|
||||
- `WarehouseGoodInfo { good, units: i32 (in magazzino), buyPrice: f64 (centesimi, prossima unità; −1 nessun venditore), buyUnits: i32, sellPrice: f64 (−1 nessun compratore), sellUnits: i32 }` (beni in magazzino o scambiabili nel bacino)
|
||||
|
||||
@@ -225,7 +227,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, e `FinanceReport` (quadro delle finanze), che il pannello «Finanze» chiede all'apertura, a ogni nuovo giorno e dopo un prestito o un rimborso.
|
||||
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, e `FleetReport` (quadro del rinnovo della flotta), che i pannelli Treni e Officine chiedono all'apertura, a ogni nuovo giorno e dopo i loro comandi.
|
||||
- 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.
|
||||
+14
-2
@@ -141,17 +141,29 @@ Aggiornato alla fine di ogni fase (guida, sezione 18).
|
||||
- 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).
|
||||
- **Ere e obsolescenza dei veicoli (issue #41, ADR 0020)**:
|
||||
- analisi delle lacune nell'ADR: ere, sblocchi per anno, rifiuto d'acquisto fuori produzione, valore di libro per età e `SellVehicle` c'erano già; mancavano notizie d'era e Cronaca, successori e modelli superati, una sola fonte del valore, costi di manutenzione dei superati, un modo di sostituire i veicoli di un treno, il quadro della flotta, la vendita nel client e l'aggiornamento dei modelli dei progetti delle IA;
|
||||
- `vehicles.json`: campo `successor` (stessa categoria, introdotto dopo, validato) e blocco `obsolescence` (perdita immediata 15 %, ammortamento 2 volte più rapido, manutenzione × 1,5 per i superati); catena vapore 1850 → 1878 → 1902 → diesel 1925, elettrica 1950 → alta velocità 1990, carrozza operai → moderna;
|
||||
- `Obsolescence` (senza stato): in produzione, superato dal 1° gennaio dell'anno del successore, successore consigliato, curva del valore, valore di libro (patrimonio) e rivendita (× condizione) da una sola fonte, fattore della manutenzione in `Fleet.CostOf`;
|
||||
- rinnovo con l'intervento «renewal» di `maintenance.json` (effetto `renew`) prenotato con `ScheduleService`: in officina, all'avvio dei lavori, i veicoli superati si vendono e il successore entra nella stessa posizione; nessun comando nuovo; rifiuto senza veicoli superati o con la spesa netta oltre la cassa meno i rinnovi già prenotati; all'avvio piano e cassa si ricontrollano e, se non bastano, il rinnovo si annulla con un avviso senza scoperto; la ricostruzione dopo un deragliamento non rende nuovo nel patrimonio un modello fuori produzione;
|
||||
- `EraSystem`: il 1° gennaio la notizia (`EventKind.Technology` = 11) dell'era che inizia e delle novità dell'anno lette dai dati (trazioni, veicoli, ponti, gallerie, binari, segnali, elettrificazione, merci, industrie, superati, fuori produzione), annotata nella Cronaca; una volta sola anche attraverso un salvataggio;
|
||||
- salvataggio invariato (corpo versione 7): nessuno stato nuovo, «renewal» in coda agli interventi;
|
||||
- IA: i modelli dei progetti superati passano al successore se non peggiora trazione, potenza e velocità, quelli fuori produzione al migliore dell'anno (che scarta i superati); ogni mese al massimo un treno in linea con veicoli superati da 3 anni o a metà vita va al rinnovo se il treno non peggiora e se resta in cassa libera il doppio della riserva (`ai.json`, `renewal`); la spesa dei rinnovi prenotati resta impegnata per borsa, industrie, progetti e treni;
|
||||
- protocollo: `DetailKind.Fleet` (10) e `FleetReport` (136); server: quadro su richiesta; `ClientWorld.Fleet`;
|
||||
- client: Treni con il catalogo dal server (fuori produzione nascosti, superati segnati con il successore, prestazioni e prezzo del successore), rivendita e «superato» sui veicoli liberi, «Vendi», treni «da rinnovare» e «Rinnova i veicoli superati» con la spesa netta; Officine con la riga di obsolescenza nella cartella, il pulsante del rinnovo e la sezione «Rinnovo della flotta» (nome dell'era, «rinnovo prenotato» al posto di «Rinnova», righe ricostruite solo all'arrivo di un nuovo quadro); testi in `strings.csv` (non provato in Godot: manca l'editor);
|
||||
- accettazione F4 (35 / 20 guasti senza la linea, 75 / 2 con la linea) e F5 invariate;
|
||||
- test (`Economy/ErasTests.cs`, 16, più il round-trip di `FleetReport`): sblocchi per anno, validazione dei successori, notizia d'era una volta anche attraverso un salvataggio, fuori produzione non acquistabile, curva del valore e rivendita, manutenzione dei superati, valore di libro uguale al patrimonio, rinnovo in officina con gli invarianti, determinismo e salvataggio con un rinnovo in corso, quadro e round-trip, cassa ricontrollata all'avvio e impegnata tra prenotazioni, rinnovo annullato con il piano vuoto, ricostruzione di un modello fuori produzione, Cronaca di un anno con soli fuori produzione, scelte delle IA, un'IA che rinnova (lento).
|
||||
- **Audio (issue #46, ADR 0022)**:
|
||||
- solo client, nessun file audio: effetti, anelli e temi sintetizzati in memoria all'avvio su un altro thread da classi senza dipendenze da Godot (`Synth`, `MusicComposer`, `AudioMix` in `scripts/Audio/`), semi fissi, PCM a 16 bit in `AudioStreamWav`;
|
||||
- bus `Master`, `Music`, `Ambience`, `Sfx`, `Ui` creati da codice in modo idempotente, limitatore sul Master; volumi per bus e muto generale nella sezione `audio` di `user://settings.cfg`; pannello «Audio» dal menu e dall'altoparlante nella barra superiore, tasto M per il muto;
|
||||
- `AudioManager` (figlio di `Main`): clic di ogni pulsante, conferma ed errore dagli esiti dei comandi, campanelle per opportunità, avvisi e notizie critiche, «cantiere completato» dal `DailyDigest`; fino a 3 treni in moto vicini al centro dello schermo con rotolamento, motore diesel o ronzio elettrico e sbuffi del vapore modulati dalla velocità (solo con un moto ricevuto da meno di 500 ms ed entro metà della diagonale dello schermo); ambiente (vento e uccelli in campagna, fiume e lago, mare, città) dalla griglia del terreno visibile e dallo zoom; tema per era dall'anno corrente con dissolvenza incrociata di 3 s;
|
||||
- nel pilota automatico e senza schermo niente sintesi e Master muto; testi in `strings.csv`;
|
||||
- nessun test nel harness (il client non è referenziato): le funzioni pure sono state provate a parte (nessun NaN, picchi entro i limiti, anelli senza salti, temi identici a ogni composizione; circa 0,1 s per gli effetti, 0,1–0,4 s per tema). Non ascoltato: qui manca l'editor. 194 test (175 senza i lenti), invariati.
|
||||
- Restano della F6: ere e obsolescenza, pannello 07, tooltip «perché», tutorial, bilanciamento con i bot.
|
||||
- Restano della F6: pannello 07, tooltip «perché», tutorial, bilanciamento con i bot.
|
||||
|
||||
## Prossimo passo
|
||||
|
||||
- F6: ere e obsolescenza, pannello 07, tooltip «perché», tutorial, bilanciamento con i bot su `simulate`.
|
||||
- F6: pannello 07, tooltip «perché», tutorial, bilanciamento con i bot su `simulate`.
|
||||
|
||||
## Limiti noti
|
||||
|
||||
|
||||
@@ -0,0 +1,169 @@
|
||||
# ADR 0020 — Ere e obsolescenza dei veicoli (F6)
|
||||
|
||||
Stato: accettato (F6, issue #41).
|
||||
|
||||
## Contesto
|
||||
|
||||
La guida (§13) chiede che la tecnologia avanzi per ere: ponti, gallerie, binari, segnali, trazioni e
|
||||
veicoli si sbloccano con l'anno, i modelli vecchi escono di produzione e quelli superati perdono valore
|
||||
e costano di più da mantenere, così che rinnovare la flotta diventi una scelta. Le ere continue e la
|
||||
ricerca (§13.2) sono della F7: il modello di questa fase deve permetterle senza riscritture. Prima di
|
||||
scrivere codice si è confrontato il motore con la guida.
|
||||
|
||||
### Analisi delle lacune
|
||||
|
||||
C'era già, e resta com'era:
|
||||
|
||||
- ere con l'anno d'inizio in `eras.json`; `TrackPlanner` vi legge tipi di ponte, limiti delle gallerie,
|
||||
classi di binario ed elettrificazione; i segnali hanno l'anno; merci e industrie hanno l'era;
|
||||
- `BuyVehicle` rifiuta i modelli non ancora introdotti o fuori produzione (`EraFrom` / `EraTo` di
|
||||
`vehicles.json`, rifiuto `EraLocked`); `Estimators` fa scegliere alle IA solo modelli disponibili;
|
||||
il catalogo del client filtrava i modelli dell'anno dai dati;
|
||||
- valore di libro dei veicoli in `FinanceSystem.BookValues` (ADR 0018): prezzo × max(minimo, 1 − età / vita);
|
||||
- `SellVehicle` (9) per i veicoli liberi in deposito, con un valore di rivendita calcolato a parte (stessa
|
||||
formula × condizione media);
|
||||
- costo di manutenzione che cresce oltre la vita utile (`ageFactor` di `maintenance.json`).
|
||||
|
||||
Mancava:
|
||||
|
||||
1. qualsiasi notizia del passaggio d'era o delle novità dell'anno, e quindi nulla nella Cronaca;
|
||||
2. il legame tra un modello e il suo successore: nessun modello era «superato», il valore scendeva con la
|
||||
sola età e la manutenzione non cambiava con l'obsolescenza;
|
||||
3. una fonte unica del valore: patrimonio e rivendita avevano due formule;
|
||||
4. un modo di sostituire i veicoli di un treno: non c'è un comando che scompone un treno e `SellVehicle`
|
||||
rifiuta i veicoli composti, quindi un treno superato si poteva solo tenere;
|
||||
5. un quadro della flotta per il client (età, superato, successore, valori);
|
||||
6. il pulsante di vendita nel client;
|
||||
7. per le IA: i modelli dei progetti restavano quelli scelti all'apertura e, fuori produzione, ogni
|
||||
`BuyVehicle` del progetto sarebbe stato rifiutato.
|
||||
|
||||
## Decisione
|
||||
|
||||
1. **Obsolescenza senza stato.** Tutto discende dai dati, dal calendario e dal giorno d'acquisto del
|
||||
veicolo (`Vehicle.BoughtDay`): `Obsolescence` (Core, statica) dice se un modello è in produzione,
|
||||
se è superato, da quale anno, qual è il successore consigliato, il residuo del valore, il valore di
|
||||
libro, la rivendita e il moltiplicatore della manutenzione. Nessun campo nuovo nel mondo.
|
||||
- In produzione: `eraFrom` ≤ anno ≤ `eraTo` (estremo compreso, come già in `BuyVehicle`).
|
||||
- Successore: nuovo campo `successor` di `vehicles.json`. Il validatore pretende un modello esistente,
|
||||
della stessa categoria (tipo, tipo di carro, classe dei passeggeri), introdotto dopo e che non chieda
|
||||
l'elettrificazione se il modello d'origine non la chiede. Catena attuale: vapore 1850 → 1878 → 1902 →
|
||||
diesel 1925; elettrica 1950 → alta velocità 1990; carrozza operai → carrozza moderna (1950).
|
||||
- Superato: dal 1° gennaio dell'anno d'introduzione del successore.
|
||||
- Successore consigliato: il più recente della catena già introdotto e ancora in produzione (la catena
|
||||
si percorre anche oltre un modello uscito di produzione).
|
||||
2. **Curva del valore.** Con età e anni da superato in anni di calendario, vita utile del modello e il
|
||||
minimo `finance.bookValueFloor` (0,1):
|
||||
- modello non superato: r = max(minimo, 1 − età / vita), come prima;
|
||||
- superato: r = max(minimo, (1 − `immediateValueLoss`) × (1 − (età + (`depreciationSpeed` − 1) × anni da
|
||||
superato) / vita)), cioè un gradino del 15 % all'arrivo del successore e poi un ammortamento due
|
||||
volte più rapido. Gli anni da superato partono dall'acquisto se il veicolo è stato comprato dopo.
|
||||
|
||||
Parametri nel nuovo blocco `obsolescence` di `vehicles.json` (con schema e intervalli validati).
|
||||
Esempio: una vaporiera del 1850 (vita 25 anni) comprata nel 1850 vale nel 1877 il minimo del 10 %;
|
||||
comprata nel 1870 vale nel 1878 il 68 % (1 − 8/25) un giorno prima e il 57,8 % il 1° gennaio.
|
||||
3. **Una sola fonte del valore.** Valore di libro = prezzo × r (centesimi, troncato) in
|
||||
`FinanceSystem.BookValues`, quindi nel patrimonio netto; rivendita = prezzo × r × condizione media dei
|
||||
componenti in `SellVehicle` e nel rinnovo; il quadro della flotta legge le stesse funzioni e il suo
|
||||
totale coincide con la voce «veicoli» dello stato patrimoniale calcolata lo stesso giorno.
|
||||
4. **Manutenzione dei superati.** `Fleet.CostOf` pesa il prezzo di ogni veicolo superato per
|
||||
`maintenanceCostFactor` (1,5): un intervento costa di più quanto più la composizione è superata. Il
|
||||
fattore tocca solo il costo in denaro, non la durata né i ricambi né l'usura. L'accettazione F4
|
||||
(Valdoria, 1850, nessun modello superato nei tre anni) resta identica.
|
||||
5. **Rinnovo con un intervento dei dati, non con un comando nuovo.** In `maintenance.json` l'intervento
|
||||
«renewal» (effetto nuovo `renew`, 4 giorni, lavoro pari allo 0,5 % dei prezzi di listino pesati dei veicoli del
|
||||
treno per il fattore della politica, nessun ricambio) si prenota con
|
||||
il comando esistente `ScheduleService` (17). In officina, **all'avvio dei lavori** (quando il treno
|
||||
prende uno stallo e si paga il lavoro), ogni veicolo superato del treno con un successore in produzione
|
||||
si vende al valore di rivendita (voce «vendita di treni») e nella stessa posizione della composizione
|
||||
entra un veicolo nuovo del successore consigliato (voce «acquisto di treni», componenti nuovi); il treno
|
||||
ricalcola prestazioni e grafo della linea e i giorni d'officina sono la messa in servizio; al
|
||||
completamento torna in linea. Il comando si rifiuta senza veicoli da rinnovare («nessun veicolo
|
||||
superato da rinnovare») e con una spesa netta (successori − rivendite + lavoro) maggiore della cassa
|
||||
meno la spesa già impegnata dagli altri rinnovi prenotati e non ancora avviati
|
||||
(`Obsolescence.Committed`). All'avvio piano, spesa e cassa si ricontrollano: tra prenotazione e avvio
|
||||
l'anno può cambiare il piano (un successore esce di produzione, altri veicoli diventano superati) e la
|
||||
cassa può essersi spesa altrove. Se il piano è vuoto o la cassa non basta, il rinnovo si annulla senza
|
||||
pagare nulla, il treno esce dall'officina e una notizia di avviso lo dice; così la cassa non va mai in
|
||||
scoperto per un rinnovo. Il piano pagato è quello del giorno dell'avvio, che può includere veicoli
|
||||
diventati superati dopo la prenotazione: salvare il piano prenotato vorrebbe dire stato nuovo nel
|
||||
salvataggio, e il controllo della cassa all'avvio basta a evitare spese non coperte. I veicoli liberi si vendono con
|
||||
`SellVehicle`, com'era. Così il rinnovo eredita prenotazione, coda, stalli, personale e notizie
|
||||
dell'officina (ADR 0009), il client non ha un comando in più e il protocollo dei comandi non cambia.
|
||||
Il validatore pretende esattamente un intervento con effetto `renew`.
|
||||
6. **Notizie d'era e novità (`EraSystem`).** Nel sistema `Eras`, dopo gli eventi del mondo e prima
|
||||
dell'hash, il 1° gennaio di ogni anno (non il giorno della fondazione) una notizia
|
||||
(`EventKind.Technology` = 11, opportunità, per tutte le compagnie) dice l'era che inizia e le novità
|
||||
lette dai dati: trazioni, veicoli introdotti («locomotiva …» per le locomotive), tipi di ponte con la
|
||||
campata, limiti delle gallerie, classi di binario, segnali, elettrificazione, merci e industrie; poi i
|
||||
modelli che diventano superati con il successore e quelli usciti di produzione. Nessun elenco è scritto
|
||||
a mano. La Cronaca del giocatore annota «inizia l'Era …» o «novità del …». Il sistema non ha stato: la
|
||||
notizia nasce nel tick del cambio d'anno e il mondo si salva tra due tick, quindi esce una volta sola
|
||||
anche attraverso un salvataggio.
|
||||
7. **Niente versione 8 del salvataggio.** Non c'è stato nuovo: superato, valori e notizie si ricavano da
|
||||
dati, calendario e `BoughtDay`, che già si salva. L'intervento «renewal» è in coda all'elenco, quindi
|
||||
gli indici degli interventi salvati (lavori in officina, storico) restano validi. Il corpo resta alla
|
||||
versione 7 e l'hash non cambia per i mondi senza modelli superati.
|
||||
8. **Quadro della flotta.** `FleetOutlook` (Core, sola lettura): era in corso e prossima, veicoli della
|
||||
compagnia (età, vita, condizione, in produzione, superato e da quando, successore consigliato, valore
|
||||
di libro, rivendita, fattore di manutenzione), catalogo dei soli modelli in produzione con il segno dei
|
||||
superati e l'ultimo anno di produzione, treni da rinnovare con la spesa netta, se la cassa basta al
|
||||
netto degli altri rinnovi prenotati e se il rinnovo è già prenotato (il client mostra «rinnovo
|
||||
prenotato» al posto di «Rinnova»). `era` e `nextEra` sono id di `eras.json`; il client mostra il nome. Protocollo: `DetailKind.Fleet` (10) e `FleetReport` (136) su richiesta, `ClientWorld.Fleet`.
|
||||
9. **Client.** Nessun calcolo: il pannello Treni prende il catalogo dal quadro (nasconde i fuori
|
||||
produzione, segna i superati con il successore e, per il modello scelto, prestazioni e prezzo del
|
||||
successore e l'ultimo anno di produzione), mostra «superato · rivendita X» sui veicoli liberi, ha
|
||||
«Vendi» (`SellVehicle`) e «Rinnova i veicoli superati» con la spesa netta, e segna i treni «da
|
||||
rinnovare»; il pannello Officine aggiunge alla cartella la riga di obsolescenza di ogni veicolo, il
|
||||
pulsante del rinnovo, e la sezione «Rinnovo della flotta» (era, prossima era, valore della flotta,
|
||||
veicoli superati con successore, valori e manutenzione, treni da rinnovare con «Rinnova»). Il quadro si
|
||||
chiede all'apertura, a ogni nuovo giorno e dopo i comandi. Testi in `strings.csv`.
|
||||
10. **IA.** Due regole deterministiche:
|
||||
- all'acquisto per un progetto, un modello superato passa al successore consigliato se questo non ha
|
||||
sforzo di trazione, potenza o velocità inferiori (`Obsolescence.NoWorseThan`), così i treni
|
||||
aggiuntivi non nascono superati per poi essere rinnovati dopo pochi anni; un modello uscito di
|
||||
produzione senza un tale successore passa al migliore dell'anno (`Estimators`), che a sua volta
|
||||
scarta i carri e le carrozze superati con un successore in produzione non peggiore (dal 1950 le
|
||||
linee passeggeri nuove hanno la carrozza moderna);
|
||||
- ogni mese, dopo la crescita delle linee, al massimo `renewal.maxTrainsPerMonth` (1) treni in linea,
|
||||
sani e non in officina, in ordine di id, si mandano al rinnovo se almeno un veicolo è superato da
|
||||
`minSupersededYears` (3) anni o ha `minAgeShareOfLife` (50 %) della vita, se il rinnovo non
|
||||
peggiora il treno (sforzo di trazione, potenza, velocità massima e rapporto potenza/massa almeno
|
||||
quelli di oggi: `Obsolescence.KeepsPerformance`) e se dopo la spesa (successori − rivendite +
|
||||
lavoro) resta in cassa libera `cashReserveMultiple` (2) volte la riserva dell'agente. Parametri nel
|
||||
blocco `renewal` di `ai.json`. La cassa libera è la cassa meno la spesa impegnata dai rinnovi
|
||||
prenotati e non ancora avviati: la usano anche borsa, acquisto d'industrie, nuovi progetti e treni,
|
||||
così lo stesso mese non spende due volte la stessa cassa.
|
||||
11. **F7.** Le ere continue e la ricerca aggiungeranno modelli e successori ai dati o anticiperanno
|
||||
`eraFrom` per compagnia: `Obsolescence` ed `EraSystem` leggono solo dati e anno, quindi basterà
|
||||
passare loro l'anno «tecnologico» della compagnia al posto di quello del calendario.
|
||||
|
||||
12. **Ricostruzione dopo un deragliamento.** L'intervento «replace» rimette i componenti a nuovo, ma
|
||||
l'età contabile (`BoughtDay`) riparte solo se il modello è ancora in produzione: un modello che non si
|
||||
compra più non torna nuovo nel patrimonio per il 45 % del prezzo; l'usura riparte comunque da capo
|
||||
(il fattore d'età torna a 1). Un modello superato ma ancora in produzione si comporta come uno nuovo
|
||||
comprato oggi, che `BuyVehicle` consente.
|
||||
|
||||
## Conseguenze
|
||||
|
||||
- Il patrimonio netto scende di più per chi tiene modelli superati; la scalata e il rating lo vedono.
|
||||
- Rinnovare costa il prezzo dei successori meno la rivendita: un treno vecchio vale poco, quindi il
|
||||
rinnovo è una spesa vera, che il pannello mostra prima della prenotazione.
|
||||
- Ogni 1° gennaio con novità c'è una notizia in più; gli anni senza novità non ne hanno.
|
||||
- Accettazione F4 invariata (35 / 20 guasti senza la linea, 75 / 2 con la linea): nel 1850–1853 nessun
|
||||
modello è superato. Accettazione F5 invariata.
|
||||
|
||||
## Limiti
|
||||
|
||||
- Il rinnovo sostituisce solo i veicoli con un successore in produzione; un modello senza successore
|
||||
(diesel, carri merci) invecchia con la sola età.
|
||||
- La rivendita non dipende dal mercato dell'usato (domanda, numero di veicoli in vendita).
|
||||
- La manutenzione dei superati costa di più ma non si guasta più spesso: il fattore tocca il prezzo, non
|
||||
l'usura.
|
||||
- Le IA rinnovano solo treni in linea e non vendono i veicoli liberi in deposito.
|
||||
- Il successore è unico per modello: niente rami (per esempio vapore → diesel o elettrica).
|
||||
- Il successore non è sempre migliore in tutto, e la scelta è voluta: la Vittoria 2-8-0 (110 kN) passa
|
||||
alla Freccia 4-6-2 (95 kN, ma 1150 kW e 110 km/h); la Freccia passa all'Aquila D1 (950 kW, 100 km/h,
|
||||
ma 180 kN, costo d'esercizio minore e trazione diesel che resta in produzione fino al 1975); la carrozza
|
||||
moderna porta più posti con più massa. Il giocatore vede prestazioni e prezzo del successore prima di
|
||||
rinnovare; le IA non rinnovano e non cambiano modello quando il treno peggiorerebbe.
|
||||
- Il piano del rinnovo è quello del giorno dell'avvio, non quello della prenotazione (vedi il punto 5).
|
||||
@@ -10,6 +10,8 @@ public sealed class AiFile
|
||||
public required int Version { get; init; }
|
||||
public required AiPlanningParams Planning { get; init; }
|
||||
public required AiMarketParams Market { get; init; }
|
||||
/// <summary>Rinnovo dei treni con veicoli superati (F6, ADR 0020).</summary>
|
||||
public required AiRenewalParams Renewal { get; init; }
|
||||
public required List<AiPersonalityDef> Personalities { get; init; }
|
||||
public required List<string> CompanyNames { get; init; }
|
||||
public required List<string> Colors { get; init; }
|
||||
@@ -77,6 +79,21 @@ public sealed class AiPlanningParams
|
||||
public required int FailedMemory { get; init; }
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Rinnovo della flotta delle IA (ADR 0020): ogni mese al più <see cref="MaxTrainsPerMonth"/> treni in
|
||||
/// servizio con un veicolo superato vanno in officina per il rinnovo, se il veicolo è superato da almeno
|
||||
/// <see cref="MinSupersededYears"/> anni o ha già consumato <see cref="MinAgeShareOfLife"/> della vita
|
||||
/// utile, e se dopo la spesa netta (successori − rivendite) la cassa resta sopra
|
||||
/// <see cref="CashReserveMultiple"/> volte la riserva dell'IA.
|
||||
/// </summary>
|
||||
public sealed class AiRenewalParams
|
||||
{
|
||||
public required double MinSupersededYears { get; init; }
|
||||
public required double MinAgeShareOfLife { get; init; }
|
||||
public required double CashReserveMultiple { get; init; }
|
||||
public required int MaxTrainsPerMonth { get; init; }
|
||||
}
|
||||
|
||||
/// <summary>Comportamento in borsa delle IA (12.1–12.2).</summary>
|
||||
public sealed class AiMarketParams
|
||||
{
|
||||
|
||||
@@ -97,6 +97,23 @@ public static class DataValidator
|
||||
break;
|
||||
}
|
||||
}
|
||||
// successori (ADR 0020): stessa categoria, introdotti dopo, senza richiedere la linea elettrificata in più
|
||||
var vehicleById = new Dictionary<string, VehicleDef>(StringComparer.Ordinal);
|
||||
foreach (var v in d.Vehicles) vehicleById.TryAdd(v.Id, v);
|
||||
bool Electric(VehicleDef v) => v.Traction is { } tr && d.Eras.Tractions.Any(x => x.Id == tr && x.NeedsElectrification);
|
||||
foreach (var v in d.Vehicles)
|
||||
{
|
||||
if (v.Successor is not { } sid) continue;
|
||||
if (!vehicleById.TryGetValue(sid, out var next))
|
||||
{
|
||||
Err("vehicles.json", $"{v.Id}: successore sconosciuto «{sid}»");
|
||||
continue;
|
||||
}
|
||||
if (next.Kind != v.Kind || next.WagonType != v.WagonType || next.Class != v.Class)
|
||||
Err("vehicles.json", $"{v.Id}: il successore «{sid}» non è della stessa categoria");
|
||||
if (next.EraFrom <= v.EraFrom) Err("vehicles.json", $"{v.Id}: il successore «{sid}» deve essere introdotto dopo");
|
||||
if (Electric(next) && !Electric(v)) Err("vehicles.json", $"{v.Id}: il successore «{sid}» richiede la linea elettrificata");
|
||||
}
|
||||
foreach (var g in d.Goods)
|
||||
{
|
||||
bool carried = d.Vehicles.Any(v => v.Kind == VehicleKind.Wagon && v.WagonType == g.Wagon && (v.Goods?.Contains(g.Id) ?? false));
|
||||
@@ -249,6 +266,8 @@ public static class DataValidator
|
||||
{
|
||||
if (i.Effect == InterventionEffect.Repair && i.RestoreTo is null) Err("maintenance.json", $"{i.Id}: una riparazione richiede restoreTo");
|
||||
}
|
||||
if (m.Interventions.Count(i => i.Effect == InterventionEffect.Renew) != 1)
|
||||
Err("maintenance.json", "serve esattamente un intervento con effetto «renew» (rinnovo dei veicoli superati)");
|
||||
RequireKeys("maintenance.json", "depots.stallsBySize", m.Depots.StallsBySize.Keys, SizeKeys, errors);
|
||||
|
||||
// --- IA, contratti, regioni
|
||||
|
||||
@@ -28,7 +28,8 @@ public enum IronmanRule { No, Optional, Yes }
|
||||
|
||||
public enum DepletionRate { Slow, Normal, Fast }
|
||||
|
||||
public enum InterventionEffect { Inspection, Service, Overhaul, Repair, Replace }
|
||||
/// <summary>Effetto di un intervento; Renew sostituisce i veicoli superati con il successore consigliato (ADR 0020).</summary>
|
||||
public enum InterventionEffect { Inspection, Service, Overhaul, Repair, Replace, Renew }
|
||||
|
||||
public enum MaintenancePolicy { Economy, Standard, Thorough }
|
||||
|
||||
|
||||
@@ -23,6 +23,8 @@ public sealed class GameData
|
||||
public required IReadOnlyList<GoodDef> Goods { get; init; }
|
||||
public required IReadOnlyList<IndustryDef> Industries { get; init; }
|
||||
public required IReadOnlyList<VehicleDef> Vehicles { get; init; }
|
||||
/// <summary>Obsolescenza dei modelli superati (vehicles.json, ADR 0020).</summary>
|
||||
public required ObsolescenceParams Obsolescence { get; init; }
|
||||
public required ErasFile Eras { get; init; }
|
||||
public required TiersFile Tiers { get; init; }
|
||||
public required BalanceFile Balance { get; init; }
|
||||
@@ -114,6 +116,7 @@ public sealed class GameData
|
||||
Goods = goods!.Goods,
|
||||
Industries = industries!.Industries,
|
||||
Vehicles = vehicles!.Vehicles,
|
||||
Obsolescence = vehicles.Obsolescence,
|
||||
Eras = eras!,
|
||||
Tiers = tiers!,
|
||||
Balance = balance!,
|
||||
@@ -197,6 +200,7 @@ public sealed class GameData
|
||||
_vehicleIndex[def.Id] = i;
|
||||
def.GoodIndices = def.Goods?.Select(g => _goodIndex[g]).ToArray() ?? [];
|
||||
}
|
||||
foreach (var def in Vehicles) def.SuccessorDef = def.Successor is { } succ ? Vehicles[_vehicleIndex[succ]] : null;
|
||||
for (int i = 0; i < Eras.TrackClasses.Count; i++) Eras.TrackClasses[i].Index = i;
|
||||
for (int i = 0; i < Events.Events.Count; i++)
|
||||
{
|
||||
|
||||
@@ -7,9 +7,24 @@ public sealed class VehiclesFile
|
||||
{
|
||||
[JsonPropertyName("$schema")] public string? Schema { get; init; }
|
||||
public required int Version { get; init; }
|
||||
/// <summary>Parametri dell'obsolescenza dei modelli superati (F6, ADR 0020).</summary>
|
||||
public required ObsolescenceParams Obsolescence { get; init; }
|
||||
public required List<VehicleDef> Vehicles { get; init; }
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Obsolescenza di un modello superato da un successore (ADR 0020): dal 1° gennaio dell'anno in cui il
|
||||
/// successore entra in produzione il valore perde subito <see cref="ImmediateValueLoss"/> e poi si
|
||||
/// ammortizza <see cref="DepreciationSpeed"/> volte più in fretta; gli interventi di manutenzione
|
||||
/// costano <see cref="MaintenanceCostFactor"/> volte tanto.
|
||||
/// </summary>
|
||||
public sealed class ObsolescenceParams
|
||||
{
|
||||
public required double ImmediateValueLoss { get; init; }
|
||||
public required double DepreciationSpeed { get; init; }
|
||||
public required double MaintenanceCostFactor { get; init; }
|
||||
}
|
||||
|
||||
/// <summary>Modello di veicolo: locomotiva, carro merci o carrozza.</summary>
|
||||
public sealed class VehicleDef
|
||||
{
|
||||
@@ -17,8 +32,15 @@ public sealed class VehicleDef
|
||||
public required VehicleKind Kind { get; init; }
|
||||
[JsonPropertyName("name_it")] public required string NameIt { get; init; }
|
||||
[JsonPropertyName("name_en")] public required string NameEn { get; init; }
|
||||
/// <summary>Anno di introduzione: da quest'anno il modello si può comprare.</summary>
|
||||
public required int EraFrom { get; init; }
|
||||
/// <summary>Ultimo anno di produzione (assente: sempre in produzione); dall'anno dopo non si compra più.</summary>
|
||||
public int? EraTo { get; init; }
|
||||
/// <summary>
|
||||
/// Modello che lo sostituisce (stessa categoria, introdotto dopo): dall'anno di introduzione del
|
||||
/// successore questo modello è «superato» (ADR 0020).
|
||||
/// </summary>
|
||||
public string? Successor { get; init; }
|
||||
public double PowerKw { get; init; }
|
||||
public double TractiveEffortKn { get; init; }
|
||||
public required double MaxSpeedKmh { get; init; }
|
||||
@@ -39,6 +61,8 @@ public sealed class VehicleDef
|
||||
public PaxClass? Class { get; init; }
|
||||
|
||||
[JsonIgnore] public int Index { get; internal set; }
|
||||
/// <summary>Successore risolto (null se il modello non ne ha).</summary>
|
||||
[JsonIgnore] public VehicleDef? SuccessorDef { get; internal set; }
|
||||
/// <summary>Indici dei beni trasportabili (carri).</summary>
|
||||
[JsonIgnore] public int[] GoodIndices { get; internal set; } = [];
|
||||
}
|
||||
@@ -0,0 +1,94 @@
|
||||
using RailEnterprise.Core.Common;
|
||||
using RailEnterprise.Core.Data;
|
||||
using RailEnterprise.Core.Simulation;
|
||||
using RailEnterprise.Core.Simulation.Systems;
|
||||
|
||||
namespace RailEnterprise.Core.Economy;
|
||||
|
||||
/// <summary>
|
||||
/// Stato di un veicolo per il rinnovo della flotta: età, condizione media, superato o no, successore
|
||||
/// consigliato, valore di libro e di rivendita, moltiplicatore dei costi di manutenzione.
|
||||
/// </summary>
|
||||
public sealed record FleetVehicleLine(
|
||||
VehicleId Id, VehicleDef Def, TrainId Train, DepotId Depot, double AgeYears, double Condition,
|
||||
bool InProduction, bool Superseded, int? SupersededYear, VehicleDef? Successor,
|
||||
Money BookValue, Money ResaleValue, double MaintenanceFactor);
|
||||
|
||||
/// <summary>Modello in produzione nell'anno, come lo mostra il catalogo d'acquisto: superato o no e successore consigliato.</summary>
|
||||
public sealed record VehicleModelLine(VehicleDef Def, bool Superseded, int? SupersededYear, VehicleDef? Successor, int? LastYear);
|
||||
|
||||
/// <summary>
|
||||
/// Treno con veicoli da rinnovare: quanti, spesa netta del rinnovo (successori − rivendite + lavoro), se la
|
||||
/// cassa basta al netto degli altri rinnovi prenotati e se il rinnovo è già prenotato (in viaggio o in coda all'officina).
|
||||
/// </summary>
|
||||
public sealed record RenewalTrainLine(TrainId Train, int Vehicles, Money NetCost, bool Affordable, bool Booked);
|
||||
|
||||
/// <summary>
|
||||
/// Quadro del rinnovo della flotta (F6, ADR 0020), in sola lettura: era in corso e prossima, veicoli
|
||||
/// della compagnia con età, obsolescenza, successore e valori, catalogo dei modelli in produzione e
|
||||
/// treni da rinnovare. Tutto viene da <see cref="Obsolescence"/>: lo stesso valore del patrimonio e
|
||||
/// della rivendita. Il client lo mostra com'è.
|
||||
/// </summary>
|
||||
public sealed class FleetOutlook
|
||||
{
|
||||
public required long Day { get; init; }
|
||||
public required int Year { get; init; }
|
||||
public required CompanyId Company { get; init; }
|
||||
public required EraDef Era { get; init; }
|
||||
public required EraDef? NextEra { get; init; }
|
||||
/// <summary>Veicoli non venduti della compagnia, in ordine di id.</summary>
|
||||
public required List<FleetVehicleLine> Vehicles { get; init; }
|
||||
/// <summary>Modelli in produzione nell'anno, nell'ordine di vehicles.json (i fuori produzione non ci sono).</summary>
|
||||
public required List<VehicleModelLine> Models { get; init; }
|
||||
/// <summary>Treni della compagnia con almeno un veicolo da rinnovare, in ordine di id.</summary>
|
||||
public required List<RenewalTrainLine> Trains { get; init; }
|
||||
/// <summary>Somma dei valori di libro: coincide con la voce «veicoli» dello stato patrimoniale calcolata oggi.</summary>
|
||||
public Money BookValueTotal => new(Vehicles.Sum(v => v.BookValue.Cents));
|
||||
|
||||
public static FleetOutlook Build(World w, CompanyId company)
|
||||
{
|
||||
var d = w.Data;
|
||||
int year = w.Clock.Year;
|
||||
double daysPerYear = w.Calendar.DaysPerYear;
|
||||
var vehicles = new List<FleetVehicleLine>();
|
||||
foreach (var v in w.Vehicles)
|
||||
{
|
||||
if (v.Sold || v.Owner != company) continue;
|
||||
bool superseded = Obsolescence.IsSuperseded(v.Def, year);
|
||||
vehicles.Add(new FleetVehicleLine(
|
||||
v.Id, v.Def, v.Train, v.Depot, (w.Clock.Day - v.BoughtDay) / daysPerYear, Obsolescence.AverageCondition(v),
|
||||
Obsolescence.InProduction(v.Def, year), superseded, Obsolescence.SupersededYear(v.Def),
|
||||
superseded ? Obsolescence.Recommended(v.Def, year) : null,
|
||||
new Money(Obsolescence.BookValueCents(w, v)), Obsolescence.ResaleValue(w, v),
|
||||
Obsolescence.MaintenanceCostFactor(d, v.Def, year)));
|
||||
}
|
||||
var models = new List<VehicleModelLine>();
|
||||
foreach (var def in d.Vehicles)
|
||||
{
|
||||
if (!Obsolescence.InProduction(def, year)) continue;
|
||||
bool superseded = Obsolescence.IsSuperseded(def, year);
|
||||
models.Add(new VehicleModelLine(def, superseded, Obsolescence.SupersededYear(def),
|
||||
superseded ? Obsolescence.Recommended(def, year) : null, def.EraTo));
|
||||
}
|
||||
var trains = new List<RenewalTrainLine>();
|
||||
var c = company.IsValid && company.Value < w.Companies.Count ? w.Companies[company.Value] : null;
|
||||
// la cassa disponibile per un rinnovo esclude la spesa impegnata dagli altri già prenotati
|
||||
var committed = Obsolescence.Committed(w, company);
|
||||
foreach (var t in w.Trains)
|
||||
{
|
||||
if (t.Removed || t.Owner != company) continue;
|
||||
var plan = Obsolescence.RenewalPlan(w, t);
|
||||
if (plan.Count == 0) continue;
|
||||
var net = Obsolescence.RenewalCost(w, t, plan);
|
||||
var available = c is null ? Money.Zero : c.Cash - (committed - Obsolescence.Commitment(w, t));
|
||||
trains.Add(new RenewalTrainLine(t.Id, plan.Count, net, c is not null && (!net.IsPositive || available >= net),
|
||||
Obsolescence.RenewalBooked(w, t)));
|
||||
}
|
||||
return new FleetOutlook
|
||||
{
|
||||
Day = w.Clock.Day, Year = year, Company = company,
|
||||
Era = EraSystem.CurrentEra(d, year), NextEra = EraSystem.NextEra(d, year),
|
||||
Vehicles = vehicles, Models = models, Trains = trains,
|
||||
};
|
||||
}
|
||||
}
|
||||
@@ -192,10 +192,11 @@ internal sealed class AiAgent
|
||||
/// <summary>Compra locomotiva e carri nel deposito del progetto, compone il treno e lo assegna alla linea.</summary>
|
||||
private bool BuyTrain(AiProject project)
|
||||
{
|
||||
UpdateModels(project);
|
||||
var loco = _w.Data.Vehicle(project.Loco);
|
||||
var car = _w.Data.Vehicle(project.Car);
|
||||
long price = Estimators.TrainPrice(loco, car, project.CarsPerTrain);
|
||||
if (_c.Cash.Cents < price + Reserve() / 2 && !Borrow(price + Reserve() / 2 - _c.Cash.Cents, completing: project.Trains.Count == 0)) return false;
|
||||
if (FreeCash() < price + Reserve() / 2 && !Borrow(price + Reserve() / 2 - FreeCash(), completing: project.Trains.Count == 0)) return false;
|
||||
var ids = new List<VehicleId>();
|
||||
var rl = Do(new BuyVehicleCommand(project.Loco, project.Depot, 1));
|
||||
if (!rl.Ok) return false;
|
||||
@@ -211,6 +212,31 @@ internal sealed class AiAgent
|
||||
return true;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Modelli superati o fuori produzione (ADR 0020): la linea passa al successore consigliato appena il
|
||||
/// modello è superato, se il successore non ha trazione, potenza o velocità inferiori (comprarlo nuovo
|
||||
/// vorrebbe dire perdere subito valore, pagare di più la manutenzione e rinnovarlo dopo pochi anni)
|
||||
/// o, se è fuori produzione e la catena non offre un tale successore, al modello che l'IA sceglierebbe
|
||||
/// oggi per un progetto nuovo. Così i treni aggiuntivi non nascono superati.
|
||||
/// </summary>
|
||||
private void UpdateModels(AiProject project)
|
||||
{
|
||||
int year = _ctx.Year;
|
||||
var loco = _w.Data.Vehicle(project.Loco);
|
||||
var newLoco = Obsolescence.IsSuperseded(loco, year) && Obsolescence.Recommended(loco, year) is { } rec && Obsolescence.NoWorseThan(rec, loco) ? rec : null;
|
||||
if (newLoco is null && !Obsolescence.InProduction(loco, year)) newLoco = Estimators.BestLocomotive(_w, year);
|
||||
if (newLoco is not null) project.Loco = newLoco.Id;
|
||||
var car = _w.Data.Vehicle(project.Car);
|
||||
var newCar = Obsolescence.IsSuperseded(car, year) && Obsolescence.Recommended(car, year) is { } recCar && Obsolescence.NoWorseThan(recCar, car) ? recCar : null;
|
||||
if (newCar is null && !Obsolescence.InProduction(car, year))
|
||||
{
|
||||
newCar = car.Kind == VehicleKind.Coach
|
||||
? Estimators.CoachFor(_w, car.Class ?? PaxClass.Worker, year)
|
||||
: project.Good >= 0 ? Estimators.WagonFor(_w, project.Good, year) : null;
|
||||
}
|
||||
if (newCar is not null) project.Car = newCar.Id;
|
||||
}
|
||||
|
||||
// ================================================================== mensile
|
||||
|
||||
public void Monthly()
|
||||
@@ -240,6 +266,7 @@ internal sealed class AiAgent
|
||||
}
|
||||
Finance();
|
||||
GrowLines();
|
||||
RenewFleet();
|
||||
StockMarket();
|
||||
BuyIndustries();
|
||||
if (!EnsurePartsSupply()) NewProject();
|
||||
@@ -287,7 +314,7 @@ internal sealed class AiAgent
|
||||
sources.Sort((a, b) => a.Km != b.Km ? a.Km.CompareTo(b.Km) : a.Key.CompareTo(b.Key));
|
||||
var loco = Estimators.BestLocomotive(_w, _ctx.Year);
|
||||
if (loco is null) return false;
|
||||
long budget = _c.Cash.Cents - Reserve() / 2 + LoanRoom();
|
||||
long budget = FreeCash() - Reserve() / 2 + LoanRoom();
|
||||
int tried = 0;
|
||||
foreach (var (pos, key, km) in sources)
|
||||
{
|
||||
@@ -315,6 +342,12 @@ internal sealed class AiAgent
|
||||
return false;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Cassa libera: la cassa meno la spesa impegnata dai rinnovi prenotati e non ancora avviati, che si
|
||||
/// paga giorni dopo a officina avviata (ADR 0020). Gli investimenti guardano questa, non la cassa intera.
|
||||
/// </summary>
|
||||
private long FreeCash() => _c.Cash.Cents - Obsolescence.Committed(_w, _c.Id).Cents;
|
||||
|
||||
/// <summary>Riserva di cassa: mesi di costi d'esercizio stimati dalla flotta e dalla rete.</summary>
|
||||
private long Reserve()
|
||||
{
|
||||
@@ -401,6 +434,48 @@ internal sealed class AiAgent
|
||||
}
|
||||
}
|
||||
|
||||
// ================================================================== rinnovo della flotta (ADR 0020)
|
||||
|
||||
/// <summary>
|
||||
/// Manda in officina per il rinnovo (intervento «renew», lo stesso comando ScheduleService del
|
||||
/// giocatore) al più renewal.maxTrainsPerMonth treni in servizio, in ordine di id, che hanno un
|
||||
/// veicolo superato da almeno renewal.minSupersededYears anni o con almeno renewal.minAgeShareOfLife
|
||||
/// della vita utile, se il rinnovo non peggiora le prestazioni del treno
|
||||
/// (<see cref="Obsolescence.KeepsPerformance"/>) e se dopo la spesa (successori − rivendite + lavoro)
|
||||
/// la cassa libera resta sopra renewal.cashReserveMultiple volte la riserva. La spesa resta impegnata
|
||||
/// (<see cref="FreeCash"/>) fino all'avvio dei lavori, così gli investimenti dello stesso mese non la riusano.
|
||||
/// </summary>
|
||||
private void RenewFleet()
|
||||
{
|
||||
var r = _w.Data.Ai.Renewal;
|
||||
if (r.MaxTrainsPerMonth <= 0) return;
|
||||
string renewal = _w.Data.Maintenance.Interventions[Obsolescence.RenewalIntervention(_w.Data)].Id;
|
||||
double daysPerYear = _w.Calendar.DaysPerYear;
|
||||
int scheduled = 0;
|
||||
foreach (var t in _w.Trains)
|
||||
{
|
||||
if (scheduled >= r.MaxTrainsPerMonth) break;
|
||||
if (t.Removed || t.Owner != _c.Id || !t.Line.IsValid || t.Reserve || t.InWorkshop || t.MaintenanceDepot.IsValid
|
||||
|| t.Failure != FailureKind.None || t.State == TrainState.Broken) continue;
|
||||
var plan = Obsolescence.RenewalPlan(_w, t);
|
||||
if (plan.Count == 0) continue;
|
||||
bool due = false;
|
||||
foreach (var item in plan)
|
||||
{
|
||||
double age = (_ctx.Day - item.Old.BoughtDay) / daysPerYear;
|
||||
if (Obsolescence.YearsSuperseded(_w, item.Old) >= r.MinSupersededYears || age >= r.MinAgeShareOfLife * item.Old.Def.LifeYears)
|
||||
{
|
||||
due = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (!due || !Obsolescence.KeepsPerformance(_w, t, plan)) continue;
|
||||
long net = Obsolescence.RenewalCost(_w, t, plan).Cents;
|
||||
if (FreeCash() - net < (long)(Reserve() * r.CashReserveMultiple)) continue;
|
||||
if (Do(new ScheduleServiceCommand(t.Id, renewal)).Ok) scheduled++;
|
||||
}
|
||||
}
|
||||
|
||||
// ================================================================== borsa (12.2)
|
||||
|
||||
private void StockMarket()
|
||||
@@ -412,13 +487,13 @@ internal sealed class AiAgent
|
||||
if (other.Defunct || other.ControlledBy != _c.Id || other.IsPlayer) continue;
|
||||
if (_ctx.Day - other.ControlSinceDay < sm.MergeAfterDays) continue;
|
||||
double minority = (other.Shares.Outstanding - other.Shares.Of(_c.Id)) * other.SharePrice;
|
||||
if (_c.Cash.Cents > minority + Reserve()) Do(new MergeCompanyCommand(other.Id));
|
||||
if (FreeCash() > minority + Reserve()) Do(new MergeCompanyCommand(other.Id));
|
||||
}
|
||||
if (!_p.BuysShares) return;
|
||||
// la Predatoria accumula quote dei concorrenti quotati (prima il giocatore) e poi lancia l'offerta;
|
||||
// solo con una rete che rende e cassa abbondante, e solo in compagnie in utile
|
||||
if (!_s.Projects.Any(p => p.Stage == AiProjectStage.Running) || _c.AnnualProfit <= 0) return;
|
||||
long budget = (long)(Math.Max(0, _c.Cash.Cents - 3 * Reserve()) * _mk.SharesCashShare);
|
||||
long budget = (long)(Math.Max(0, FreeCash() - 3 * Reserve()) * _mk.SharesCashShare);
|
||||
if (budget <= 0) return;
|
||||
foreach (var target in _w.Companies.OrderByDescending(t => t.IsPlayer).ThenBy(t => t.Id.Value))
|
||||
{
|
||||
@@ -452,7 +527,7 @@ internal sealed class AiAgent
|
||||
long needed = (long)Math.Ceiling(goal * target.Shares.Outstanding) - target.Shares.Of(_c.Id);
|
||||
if (needed <= 0) return false;
|
||||
double cost = (double)needed * price;
|
||||
if (_c.Cash.Cents < cost * _mk.BidCashMultiple + Reserve()) return false;
|
||||
if (FreeCash() < cost * _mk.BidCashMultiple + Reserve()) return false;
|
||||
return Do(new LaunchBidCommand(target.Id, new Money(price), goal)).Ok;
|
||||
}
|
||||
|
||||
@@ -505,7 +580,7 @@ internal sealed class AiAgent
|
||||
private void BuyIndustries()
|
||||
{
|
||||
if (!Tiers.Unlocks(_w, _c).BuyIndustry || _s.LastIndustryYear == _ctx.Year) return;
|
||||
long budget = (long)(Math.Max(0, _c.Cash.Cents - Reserve()) * _mk.IndustryMaxCashShare);
|
||||
long budget = (long)(Math.Max(0, FreeCash() - Reserve()) * _mk.IndustryMaxCashShare);
|
||||
if (budget <= 0) return;
|
||||
var served = Tiers.ServedStations(_w, _c.Id);
|
||||
Industry? best = null;
|
||||
@@ -571,7 +646,7 @@ internal sealed class AiAgent
|
||||
{
|
||||
int open = _s.Projects.Count(p => p.Stage is AiProjectStage.Construction or AiProjectStage.Equip);
|
||||
if (open >= _plan.MaxConcurrentProjects) return;
|
||||
long budget = _c.Cash.Cents - Reserve() + LoanRoom();
|
||||
long budget = FreeCash() - Reserve() + LoanRoom();
|
||||
if (budget <= 0) return;
|
||||
var loco = Estimators.BestLocomotive(_w, _ctx.Year);
|
||||
if (loco is null) return;
|
||||
@@ -1147,7 +1222,7 @@ internal sealed class AiAgent
|
||||
/// <summary>Apre i cantieri del progetto: stazioni, deposito, binario e raccordo del deposito.</summary>
|
||||
private void Execute(Proposal p, DepotId? supply = null)
|
||||
{
|
||||
long need = p.Capital + Reserve() - _c.Cash.Cents;
|
||||
long need = p.Capital + Reserve() - FreeCash();
|
||||
if (need > 0 && !Borrow(need)) return;
|
||||
var cand = p.Candidate;
|
||||
var stationA = p.ExistingA;
|
||||
|
||||
@@ -30,8 +30,9 @@ public sealed class AiProject
|
||||
public long CapitalCents { get; init; }
|
||||
public long RevenuePerYearCents { get; init; }
|
||||
public int TrainsPlanned { get; set; }
|
||||
public required string Loco { get; init; }
|
||||
public required string Car { get; init; }
|
||||
/// <summary>Modelli dei treni della linea; se escono di produzione si passa al successore (ADR 0020).</summary>
|
||||
public required string Loco { get; set; }
|
||||
public required string Car { get; set; }
|
||||
public int CarsPerTrain { get; init; }
|
||||
/// <summary>Giorno prima del quale non si aggiungono treni (dopo uno stallo risolto).</summary>
|
||||
public long GrowAfterDay { get; set; }
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
using RailEnterprise.Core.Common;
|
||||
using RailEnterprise.Core.Data;
|
||||
using RailEnterprise.Core.Economy;
|
||||
using RailEnterprise.Core.Simulation.Systems;
|
||||
|
||||
namespace RailEnterprise.Core.Simulation;
|
||||
|
||||
@@ -64,26 +65,33 @@ public static class Estimators
|
||||
return best;
|
||||
}
|
||||
|
||||
/// <summary>Carro più economico che trasporta il bene nell'anno.</summary>
|
||||
/// <summary>
|
||||
/// Vero se il modello è superato e il suo successore consigliato si compra e non è peggiore: chi sceglie
|
||||
/// un modello nuovo (IA, stime) lo scarta per non comprare un veicolo che perde subito valore (ADR 0020).
|
||||
/// </summary>
|
||||
private static bool Outdated(VehicleDef v, int year) =>
|
||||
Obsolescence.IsSuperseded(v, year) && Obsolescence.Recommended(v, year) is { } next && Obsolescence.NoWorseThan(next, v);
|
||||
|
||||
/// <summary>Carro più economico che trasporta il bene nell'anno, esclusi i superati con un successore in produzione.</summary>
|
||||
public static VehicleDef? WagonFor(World w, int good, int year)
|
||||
{
|
||||
VehicleDef? best = null;
|
||||
foreach (var v in w.Data.Vehicles)
|
||||
{
|
||||
if (v.Kind != VehicleKind.Wagon || v.EraFrom > year || (v.EraTo is { } to && year > to)) continue;
|
||||
if (v.Kind != VehicleKind.Wagon || v.EraFrom > year || (v.EraTo is { } to && year > to) || Outdated(v, year)) continue;
|
||||
if (Array.IndexOf(v.GoodIndices, good) < 0) continue;
|
||||
if (best is null || v.Price < best.Price) best = v;
|
||||
}
|
||||
return best;
|
||||
}
|
||||
|
||||
/// <summary>Carrozza della classe indicata disponibile nell'anno.</summary>
|
||||
/// <summary>Carrozza più economica della classe indicata disponibile nell'anno, esclusi i superati con un successore in produzione.</summary>
|
||||
public static VehicleDef? CoachFor(World w, PaxClass cls, int year)
|
||||
{
|
||||
VehicleDef? best = null;
|
||||
foreach (var v in w.Data.Vehicles)
|
||||
{
|
||||
if (v.Kind != VehicleKind.Coach || v.Class != cls || v.EraFrom > year || (v.EraTo is { } to && year > to)) continue;
|
||||
if (v.Kind != VehicleKind.Coach || v.Class != cls || v.EraFrom > year || (v.EraTo is { } to && year > to) || Outdated(v, year)) continue;
|
||||
if (best is null || v.Price < best.Price) best = v;
|
||||
}
|
||||
return best;
|
||||
|
||||
@@ -20,6 +20,8 @@ public enum EventKind : byte
|
||||
Company = 9,
|
||||
/// <summary>Evento del mondo (events.json, ADR 0017): inizio e fine.</summary>
|
||||
World = 10,
|
||||
/// <summary>Passaggio d'era e novità tecnologiche dell'anno (ADR 0020).</summary>
|
||||
Technology = 11,
|
||||
}
|
||||
|
||||
/// <summary>Riferimento facoltativo all'entità coinvolta.</summary>
|
||||
|
||||
@@ -74,13 +74,26 @@ public static class MaintenanceCommandHandlers
|
||||
if (!TryTrain(w, c.Train, company, out var train)) return reply(CommandError.NotFound, "Treno inesistente");
|
||||
var m = w.Data.Maintenance;
|
||||
int idx = m.InterventionIndex(c.Intervention);
|
||||
if (idx < 0 || m.Interventions[idx].Effect is not (InterventionEffect.Inspection or InterventionEffect.Service or InterventionEffect.Overhaul))
|
||||
return reply(CommandError.InvalidArgument, "Intervento: inspection, service o overhaul");
|
||||
if (idx < 0 || m.Interventions[idx].Effect is not (InterventionEffect.Inspection or InterventionEffect.Service or InterventionEffect.Overhaul or InterventionEffect.Renew))
|
||||
return reply(CommandError.InvalidArgument, $"Intervento: inspection, service, overhaul o {m.Interventions.First(i => i.Effect == InterventionEffect.Renew).Id}");
|
||||
if (train.Vehicles.Count == 0) return reply(CommandError.NotAllowed, "Treno senza veicoli");
|
||||
if (train.InWorkshop) return reply(CommandError.NotAllowed, $"{train.Name} è già in officina");
|
||||
if (train.State == TrainState.Broken) return reply(CommandError.NotAllowed, $"{train.Name} attende il soccorso");
|
||||
if (train.Failure != FailureKind.None) return reply(CommandError.NotAllowed, $"{train.Name} ha un guasto: prima la riparazione");
|
||||
var def = m.Interventions[idx];
|
||||
if (def.Effect == InterventionEffect.Renew)
|
||||
{
|
||||
// rinnovo (ADR 0020): serve almeno un veicolo superato con un successore in produzione e la cassa
|
||||
// per la spesa netta, al netto degli altri rinnovi già prenotati; all'avvio dei lavori si ricontrolla
|
||||
var plan = Obsolescence.RenewalPlan(w, train);
|
||||
if (plan.Count == 0) return reply(CommandError.NotAllowed, $"{train.Name}: nessun veicolo superato da rinnovare");
|
||||
var net = Obsolescence.RenewalCost(w, train, plan);
|
||||
var committed = Obsolescence.Committed(w, company.Id, train);
|
||||
if (net.IsPositive && company.Cash - committed < net)
|
||||
return reply(CommandError.InsufficientFunds, committed.IsPositive
|
||||
? $"Il rinnovo di {train.Name} costa {net} al netto delle rivendite: cassa insufficiente (già impegnati {committed} in altri rinnovi)"
|
||||
: $"Il rinnovo di {train.Name} costa {net} al netto delle rivendite: cassa insufficiente");
|
||||
}
|
||||
int parts = Fleet.PartsFor(w, train, def);
|
||||
FleetMaintenanceSystem.CancelBooking(train);
|
||||
if (!FleetMaintenanceSystem.Book(ctx, train, idx, parts, requireParts: true))
|
||||
|
||||
@@ -408,14 +408,11 @@ public static class RailCommandHandlers
|
||||
return reply(CommandError.None, $"Venduto per {value}");
|
||||
}
|
||||
|
||||
/// <summary>Valore di rivendita: prezzo × (1 − età/vita, minimo 10 %) × condizione media.</summary>
|
||||
public static Money ResaleValue(World w, Vehicle v)
|
||||
{
|
||||
double ageYears = (w.Clock.Day - v.BoughtDay) / (double)w.Calendar.DaysPerYear;
|
||||
double residual = Math.Max(w.Data.Balance.Finance.BookValueFloor, 1 - ageYears / v.Def.LifeYears);
|
||||
double condition = v.Components.Length == 0 ? 1 : v.Components.Average() / 100;
|
||||
return new Money(v.Def.Price) * (residual * condition);
|
||||
}
|
||||
/// <summary>
|
||||
/// Valore di rivendita: prezzo × residuo (1 − età/vita, minimo 10 %, più rapido per i modelli
|
||||
/// superati) × condizione media; la curva è in <see cref="Obsolescence"/> (ADR 0020).
|
||||
/// </summary>
|
||||
public static Money ResaleValue(World w, Vehicle v) => Obsolescence.ResaleValue(w, v);
|
||||
|
||||
public static CommandResult ComposeTrain(World w, Company company, ComposeTrainCommand c, Reply reply)
|
||||
{
|
||||
|
||||
@@ -9,7 +9,7 @@ namespace RailEnterprise.Core.Simulation;
|
||||
/// inseriscono nella loro posizione quando vengono implementati:
|
||||
/// Clock → Commands → Construction → Trains → Signals → Stations (+ trasporto locale)
|
||||
/// → Maintenance → Demand → Commuting → Industries → IndustryMaintenance → Towns → Market
|
||||
/// → Finance → StockMarket → AiAgents → Events → Contracts → Hash.
|
||||
/// → Finance → StockMarket → AiAgents → Events → Eras (F6, ADR 0020) → Contracts → Hash.
|
||||
/// </summary>
|
||||
public sealed class SystemPipeline(IReadOnlyList<ISimSystem> systems)
|
||||
{
|
||||
@@ -43,6 +43,7 @@ public sealed class SystemPipeline(IReadOnlyList<ISimSystem> systems)
|
||||
new StockMarketSystem(),
|
||||
new AiSystem(),
|
||||
new EventSystem(),
|
||||
new EraSystem(),
|
||||
new HashSystem(),
|
||||
]);
|
||||
|
||||
|
||||
@@ -0,0 +1,157 @@
|
||||
using System.Globalization;
|
||||
using RailEnterprise.Core.Common;
|
||||
using RailEnterprise.Core.Data;
|
||||
|
||||
namespace RailEnterprise.Core.Simulation.Systems;
|
||||
|
||||
/// <summary>Tipo di novità tecnologica di un anno (ADR 0020).</summary>
|
||||
public enum TechKind : byte
|
||||
{
|
||||
Traction = 0,
|
||||
Vehicle = 1,
|
||||
BridgeType = 2,
|
||||
TunnelLimit = 3,
|
||||
TrackClass = 4,
|
||||
Signal = 5,
|
||||
Electrification = 6,
|
||||
Good = 7,
|
||||
Industry = 8,
|
||||
}
|
||||
|
||||
/// <summary>Novità che un anno sblocca: tipo, id nei dati (vuoto per gallerie ed elettrificazione) e testo italiano.</summary>
|
||||
public readonly record struct TechUnlock(TechKind Kind, string Id, string TextIt);
|
||||
|
||||
/// <summary>
|
||||
/// Passaggi d'era e novità tecnologiche (F6, ADR 0020). Il 1° gennaio di ogni anno (non il giorno della
|
||||
/// fondazione) annuncia, se ce ne sono, le novità di quell'anno lette dai dati: inizio di un'era
|
||||
/// (eras.json), trazioni, veicoli introdotti, tipi di ponte, limiti delle gallerie, classi di binario,
|
||||
/// segnali, elettrificazione, merci e industrie; poi i modelli che escono di produzione e quelli che
|
||||
/// diventano superati. Nessun elenco è scritto a mano. La notizia (<see cref="EventKind.Technology"/>)
|
||||
/// va a tutte le compagnie e la Cronaca del giocatore la registra come fatto saliente.
|
||||
///
|
||||
/// Il sistema non ha stato: la notizia nasce nel tick del cambio d'anno, che un salvataggio non ripete
|
||||
/// (il mondo si salva tra un tick e l'altro), quindi esce una volta sola anche passando da un
|
||||
/// salvataggio. Le ere continue della F7 aggiungeranno modelli ai dati: questo sistema li annuncerà
|
||||
/// senza cambiare.
|
||||
/// </summary>
|
||||
public sealed class EraSystem : ISimSystem
|
||||
{
|
||||
public string Name => "Eras";
|
||||
|
||||
public void Step(WorldContext ctx)
|
||||
{
|
||||
if (!ctx.IsNewYear || ctx.Day == 0) return;
|
||||
Announce(ctx.World, ctx.Year);
|
||||
}
|
||||
|
||||
/// <summary>Emette la notizia delle novità dell'anno (se ce ne sono) e la annota nella Cronaca del giocatore.</summary>
|
||||
public static GameEvent? Announce(World w, int year)
|
||||
{
|
||||
string? text = NewsText(w.Data, year);
|
||||
if (text is null) return null;
|
||||
var era = EraStarting(w.Data, year);
|
||||
var e = new GameEvent(w.Clock.Day, EventKind.Technology, EventSeverity.Opportunity, text, Company: CompanyId.None);
|
||||
w.Events.Add(e);
|
||||
if (w.Companies.Count > 0)
|
||||
Corporate.Milestone(w, w.Player, era is not null ? $"inizia l'{era.NameIt}" : $"novità del {year}: {string.Join("; ", NewsParts(w.Data, year))}");
|
||||
return e;
|
||||
}
|
||||
|
||||
/// <summary>Era in corso nell'anno: l'ultima iniziata (la prima se l'anno la precede).</summary>
|
||||
public static EraDef CurrentEra(GameData d, int year)
|
||||
{
|
||||
var eras = d.Eras.Eras;
|
||||
var current = eras[0];
|
||||
foreach (var e in eras)
|
||||
{
|
||||
if (e.From <= year) current = e;
|
||||
}
|
||||
return current;
|
||||
}
|
||||
|
||||
/// <summary>Prossima era dopo l'anno (null all'ultima).</summary>
|
||||
public static EraDef? NextEra(GameData d, int year) => d.Eras.Eras.FirstOrDefault(e => e.From > year);
|
||||
|
||||
/// <summary>Era che inizia esattamente nell'anno (null se nessuna).</summary>
|
||||
public static EraDef? EraStarting(GameData d, int year) => d.Eras.Eras.FirstOrDefault(e => e.From == year);
|
||||
|
||||
/// <summary>Novità introdotte nell'anno, nell'ordine dei file dati.</summary>
|
||||
public static List<TechUnlock> Unlocks(GameData d, int year)
|
||||
{
|
||||
var list = new List<TechUnlock>();
|
||||
var eras = d.Eras;
|
||||
foreach (var t in eras.Tractions)
|
||||
{
|
||||
if (t.From == year) list.Add(new TechUnlock(TechKind.Traction, t.Id.ToString().ToLowerInvariant(), $"trazione {t.NameIt.ToLowerInvariant()}"));
|
||||
}
|
||||
foreach (var v in d.Vehicles)
|
||||
{
|
||||
if (v.EraFrom == year) list.Add(new TechUnlock(TechKind.Vehicle, v.Id, v.Kind == VehicleKind.Locomotive ? $"locomotiva {v.NameIt}" : v.NameIt.ToLowerInvariant()));
|
||||
}
|
||||
foreach (var b in eras.BridgeTypes)
|
||||
{
|
||||
if (b.From == year) list.Add(new TechUnlock(TechKind.BridgeType, b.Id, $"ponti in {b.NameIt.ToLowerInvariant()} con campate fino a {Number(b.MaxSpanM)} m"));
|
||||
}
|
||||
foreach (var t in eras.TunnelLimits)
|
||||
{
|
||||
if (t.From == year) list.Add(new TechUnlock(TechKind.TunnelLimit, "", $"gallerie fino a {Number(t.MaxLengthM / 1000)} km"));
|
||||
}
|
||||
foreach (var c in eras.TrackClasses)
|
||||
{
|
||||
if (c.From == year) list.Add(new TechUnlock(TechKind.TrackClass, c.Id, $"binario {c.NameIt}"));
|
||||
}
|
||||
foreach (var s in eras.Signals)
|
||||
{
|
||||
if (s.From == year) list.Add(new TechUnlock(TechKind.Signal, s.Id, s.NameIt.ToLowerInvariant()));
|
||||
}
|
||||
if (eras.ElectrificationFrom == year) list.Add(new TechUnlock(TechKind.Electrification, "", "elettrificazione delle linee"));
|
||||
foreach (var g in d.Goods)
|
||||
{
|
||||
if (g.Era == year) list.Add(new TechUnlock(TechKind.Good, g.Id, $"merce {g.NameIt.ToLowerInvariant()}"));
|
||||
}
|
||||
foreach (var i in d.Industries)
|
||||
{
|
||||
if (i.Era == year) list.Add(new TechUnlock(TechKind.Industry, i.Id, $"industria {i.NameIt.ToLowerInvariant()}"));
|
||||
}
|
||||
return list;
|
||||
}
|
||||
|
||||
/// <summary>Modelli fuori produzione dall'anno (ultimo anno di produzione l'anno prima).</summary>
|
||||
public static List<VehicleDef> Retired(GameData d, int year) => d.Vehicles.Where(v => v.EraTo == year - 1).ToList();
|
||||
|
||||
/// <summary>Modelli che nell'anno diventano superati (il successore è introdotto quell'anno).</summary>
|
||||
public static List<VehicleDef> NewlySuperseded(GameData d, int year) => d.Vehicles.Where(v => v.SuccessorDef?.EraFrom == year).ToList();
|
||||
|
||||
/// <summary>Testo della notizia dell'anno, o null se l'anno non porta nulla di nuovo.</summary>
|
||||
public static string? NewsText(GameData d, int year)
|
||||
{
|
||||
var era = EraStarting(d, year);
|
||||
var parts = NewsParts(d, year);
|
||||
if (era is null && parts.Count == 0) return null;
|
||||
string head = era is not null ? $"Inizia l'{era.NameIt} ({year})" : $"Novità del {year}";
|
||||
return parts.Count == 0 ? head : $"{head}: {string.Join("; ", parts)}";
|
||||
}
|
||||
|
||||
/// <summary>Parti della notizia dell'anno: sblocchi, modelli superati, fuori produzione (vuota se nessuna).</summary>
|
||||
public static List<string> NewsParts(GameData d, int year)
|
||||
{
|
||||
var unlocks = Unlocks(d, year);
|
||||
var retired = Retired(d, year);
|
||||
var superseded = NewlySuperseded(d, year);
|
||||
var parts = new List<string>();
|
||||
if (unlocks.Count > 0) parts.Add($"sblocca {Join(unlocks.Select(u => u.TextIt))}");
|
||||
if (superseded.Count > 0)
|
||||
parts.Add($"{(superseded.Count == 1 ? "modello superato" : "modelli superati")}: {Join(superseded.Select(v => $"{v.NameIt} (successore {v.SuccessorDef!.NameIt})"))}");
|
||||
if (retired.Count > 0) parts.Add($"fuori produzione: {Join(retired.Select(v => v.NameIt))}");
|
||||
return parts;
|
||||
}
|
||||
|
||||
private static string Join(IEnumerable<string> items)
|
||||
{
|
||||
var list = items.ToList();
|
||||
return list.Count <= 1 ? string.Concat(list) : $"{string.Join(", ", list.Take(list.Count - 1))} e {list[^1]}";
|
||||
}
|
||||
|
||||
private static string Number(double value) =>
|
||||
value.ToString("0.#", CultureInfo.InvariantCulture).Replace('.', ',');
|
||||
}
|
||||
@@ -221,8 +221,8 @@ public sealed class FinanceSystem : ISimSystem
|
||||
foreach (var v in w.Vehicles)
|
||||
{
|
||||
if (v.Sold) continue;
|
||||
double age = (today - v.BoughtDay) / daysPerYear;
|
||||
values[v.Owner.Value][vehicles] += (long)(v.Def.Price * Math.Max(fb.BookValueFloor, 1 - age / v.Def.LifeYears));
|
||||
// stessa curva della rivendita, con l'obsolescenza dei modelli superati (ADR 0020)
|
||||
values[v.Owner.Value][vehicles] += Obsolescence.BookValueCents(w, v);
|
||||
}
|
||||
foreach (var ind in w.Industries)
|
||||
{
|
||||
|
||||
@@ -173,27 +173,35 @@ public static class Fleet
|
||||
public static int PartsFor(World w, Train t, InterventionDef def) =>
|
||||
def.Effect == InterventionEffect.Repair ? def.SpareParts : def.SpareParts * t.Vehicles.Count;
|
||||
|
||||
/// <summary>Costo dell'intervento: quota del prezzo dei veicoli interessati × fattore di costo della politica.</summary>
|
||||
/// <summary>
|
||||
/// Costo dell'intervento: quota del prezzo dei veicoli interessati × fattore di costo della politica;
|
||||
/// il prezzo di un modello superato conta maintenanceCostFactor volte (ricambi fuori catalogo, ADR 0020).
|
||||
/// </summary>
|
||||
public static Money CostOf(World w, Train t, InterventionDef def, PolicyDef policy)
|
||||
{
|
||||
long price = 0;
|
||||
double price = 0;
|
||||
int year = w.Clock.Year;
|
||||
if (def.Effect == InterventionEffect.Repair)
|
||||
{
|
||||
if (t.FailedVehicle.IsValid) price = w.Vehicles[t.FailedVehicle.Value].Def.Price;
|
||||
if (t.FailedVehicle.IsValid) price = WeightedPrice(w.Data, w.Vehicles[t.FailedVehicle.Value].Def, year);
|
||||
}
|
||||
else
|
||||
{
|
||||
foreach (var id in t.Vehicles) price += w.Vehicles[id.Value].Def.Price;
|
||||
foreach (var id in t.Vehicles) price += WeightedPrice(w.Data, w.Vehicles[id.Value].Def, year);
|
||||
}
|
||||
return Money.FromCentsRounded(price * def.CostShare * policy.CostFactor);
|
||||
}
|
||||
|
||||
private static double WeightedPrice(GameData d, VehicleDef def, int year) => def.Price * Obsolescence.MaintenanceCostFactor(d, def, year);
|
||||
|
||||
/// <summary>Applica gli effetti dell'intervento ai veicoli del treno (10.2), scalati dalla politica.</summary>
|
||||
public static void Apply(World w, Train t, InterventionDef def, PolicyDef policy)
|
||||
{
|
||||
var m = w.Data.Maintenance;
|
||||
long today = w.Clock.Day;
|
||||
double ef = policy.EffectFactor;
|
||||
// rinnovo: i veicoli superati si sono già sostituiti all'avvio dei lavori, quando si è pagato (ADR 0020)
|
||||
if (def.Effect == InterventionEffect.Renew) return;
|
||||
foreach (var id in t.Vehicles)
|
||||
{
|
||||
var v = w.Vehicles[id.Value];
|
||||
@@ -227,11 +235,17 @@ public static class Fleet
|
||||
Raise(v, t.FailedComponent, def.RestoreTo ?? 100, ef);
|
||||
break;
|
||||
case InterventionEffect.Replace:
|
||||
// veicolo sostituito: nuovo di fabbrica
|
||||
// veicolo ricostruito: componenti nuovi di fabbrica. L'età contabile riparte solo se il
|
||||
// modello è ancora in produzione: un modello che non si compra più non torna nuovo nel
|
||||
// patrimonio (ADR 0020), l'usura però riparte da capo
|
||||
for (int j = 0; j < v.Components.Length; j++) v.Components[j] = 100;
|
||||
v.BoughtDay = today;
|
||||
if (Obsolescence.InProduction(v.Def, w.Clock.Year))
|
||||
{
|
||||
v.BoughtDay = today;
|
||||
v.AgeFactorOffset = 0;
|
||||
}
|
||||
else v.AgeFactorOffset = Math.Max(0, RawAgeFactor(m.Wear, v, today, w.Calendar.DaysPerYear) - 1);
|
||||
v.OdometerKm = 0;
|
||||
v.AgeFactorOffset = 0;
|
||||
Array.Clear(v.WearEma);
|
||||
MarkInspection(v, today);
|
||||
MarkService(v, today);
|
||||
|
||||
@@ -489,7 +489,13 @@ public sealed class FleetMaintenanceSystem : ISimSystem
|
||||
waitingParts = true;
|
||||
continue;
|
||||
}
|
||||
Start(ctx, d, job, t, rate);
|
||||
if (!Start(ctx, d, job, t, rate))
|
||||
{
|
||||
// rinnovo annullato all'avvio: il treno esce dall'officina senza lavori
|
||||
d.Jobs.RemoveAt(i--);
|
||||
inStall--;
|
||||
continue;
|
||||
}
|
||||
}
|
||||
job.Progress += rate;
|
||||
if (job.Progress + 1e-9 < job.Days) continue;
|
||||
@@ -507,19 +513,50 @@ public sealed class FleetMaintenanceSystem : ISimSystem
|
||||
else if (!waitingParts) d.PartsAlerted = false;
|
||||
}
|
||||
|
||||
private static void Start(WorldContext ctx, Depot d, WorkshopJob job, Train t, double rate)
|
||||
/// <summary>Avvia il lavoro: preleva i ricambi e paga l'intervento. Falso se un rinnovo si annulla.</summary>
|
||||
private static bool Start(WorldContext ctx, Depot d, WorkshopJob job, Train t, double rate)
|
||||
{
|
||||
var w = ctx.World;
|
||||
var m = w.Data.Maintenance;
|
||||
var def = m.Interventions[job.Intervention];
|
||||
var cost = Fleet.CostOf(w, t, def, Fleet.PolicyOf(w, t));
|
||||
List<RenewalItem>? plan = null;
|
||||
if (def.Effect == InterventionEffect.Renew)
|
||||
{
|
||||
// rinnovo (ADR 0020): piano, spesa e cassa si controllano qui, quando si paga, non solo alla
|
||||
// prenotazione: tra le due l'anno può cambiare il piano e la cassa può essersi spesa altrove
|
||||
plan = Obsolescence.RenewalPlan(w, t);
|
||||
var total = Obsolescence.NetCost(plan) + cost;
|
||||
var company = w.Companies[t.Owner.Value];
|
||||
string? why = plan.Count == 0 ? "nessun veicolo superato con un successore in produzione"
|
||||
: total.IsPositive && company.Cash < total ? $"cassa insufficiente per la spesa netta di {total}" : null;
|
||||
if (why is not null)
|
||||
{
|
||||
t.InWorkshop = false;
|
||||
t.MaintenanceDepot = DepotId.None;
|
||||
t.PlannedIntervention = -1;
|
||||
w.Events.Add(new GameEvent(ctx.Day, EventKind.Maintenance, EventSeverity.Warning,
|
||||
$"{t.Name}: rinnovo annullato a {d.Name}, {why}", EntityKind.Train, t.Id.Value, t.Owner));
|
||||
return false;
|
||||
}
|
||||
}
|
||||
d.SpareParts -= job.Parts;
|
||||
w.Goods.Consumed[w.Data.SparePartsGood] += job.Parts;
|
||||
var cost = Fleet.CostOf(w, t, def, Fleet.PolicyOf(w, t));
|
||||
if (cost.IsPositive) w.Money.Transfer(Account.Of(t.Owner), Account.External, cost, LedgerEntry.FleetMaintenance);
|
||||
job.CostCents = cost.Cents;
|
||||
job.Started = true;
|
||||
t.MaintenanceThisYear += cost.Cents;
|
||||
if (plan is not null)
|
||||
{
|
||||
// i veicoli si sostituiscono all'avvio, con il piano appena pagato; i giorni d'officina sono la messa in servizio
|
||||
var net = Obsolescence.NetCost(plan);
|
||||
int renewed = Obsolescence.Renew(w, t, plan);
|
||||
string what = renewed == 1 ? "1 veicolo sostituito" : $"{renewed} veicoli sostituiti";
|
||||
w.Events.Add(new GameEvent(ctx.Day, EventKind.Maintenance, EventSeverity.Info,
|
||||
$"{t.Name}: rinnovo avviato a {d.Name}, {what} (spesa netta {net + cost})", EntityKind.Train, t.Id.Value, t.Owner));
|
||||
}
|
||||
if (job.Days / rate >= m.Planner.ReserveMinDays) Cover(ctx, t, d);
|
||||
return true;
|
||||
}
|
||||
|
||||
private static void Complete(WorldContext ctx, Depot d, WorkshopJob job, Train t)
|
||||
@@ -549,6 +586,11 @@ public sealed class FleetMaintenanceSystem : ISimSystem
|
||||
w.Events.Add(new GameEvent(ctx.Day, EventKind.Maintenance, EventSeverity.Info,
|
||||
$"{t.Name}: {def.NameIt.ToLowerInvariant()} completata a {d.Name}", EntityKind.Train, t.Id.Value, t.Owner));
|
||||
}
|
||||
else if (def.Effect == InterventionEffect.Renew)
|
||||
{
|
||||
w.Events.Add(new GameEvent(ctx.Day, EventKind.Maintenance, EventSeverity.Info,
|
||||
$"{t.Name}: rinnovo completato a {d.Name}", EntityKind.Train, t.Id.Value, t.Owner));
|
||||
}
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------ riserve
|
||||
|
||||
@@ -0,0 +1,226 @@
|
||||
using RailEnterprise.Core.Common;
|
||||
using RailEnterprise.Core.Data;
|
||||
using RailEnterprise.Core.Economy;
|
||||
using RailEnterprise.Core.Rail;
|
||||
using RailEnterprise.Core.Time;
|
||||
|
||||
namespace RailEnterprise.Core.Simulation.Systems;
|
||||
|
||||
/// <summary>Veicolo superato da rinnovare: il successore consigliato, il suo prezzo e la rivendita del vecchio.</summary>
|
||||
public readonly record struct RenewalItem(Vehicle Old, VehicleDef Successor, Money Price, Money Resale);
|
||||
|
||||
/// <summary>
|
||||
/// Produzione, obsolescenza e valore dei veicoli (F6, ADR 0020), senza stato: tutto discende dai dati
|
||||
/// (anno di introduzione, ultimo anno di produzione, successore di vehicles.json), dal calendario e dal
|
||||
/// giorno d'acquisto del veicolo. È l'unica fonte del valore di un veicolo: il valore di libro del
|
||||
/// patrimonio (<see cref="FinanceSystem.BookValues"/>), la rivendita di <c>SellVehicle</c>, il rinnovo e
|
||||
/// i quadri del client leggono le stesse funzioni.
|
||||
///
|
||||
/// Curva del valore (residuo r, frazione del prezzo, con il minimo <c>finance.bookValueFloor</c>):
|
||||
/// - modello non superato: r = 1 − età / vita;
|
||||
/// - superato (dal 1° gennaio dell'anno d'introduzione del successore, o dall'acquisto se è successivo):
|
||||
/// r = (1 − perdita) × (1 − (età + (velocità − 1) × anni da superato) / vita), cioè un gradino di
|
||||
/// <c>immediateValueLoss</c> e poi un ammortamento <c>depreciationSpeed</c> volte più rapido.
|
||||
/// Valore di libro = prezzo × r; rivendita = prezzo × r × condizione media dei componenti.
|
||||
/// </summary>
|
||||
public static class Obsolescence
|
||||
{
|
||||
/// <summary>Vero se il modello si può comprare nell'anno: introdotto e non ancora fuori produzione.</summary>
|
||||
public static bool InProduction(VehicleDef def, int year) => def.EraFrom <= year && (def.EraTo is not { } to || year <= to);
|
||||
|
||||
/// <summary>Vero se il successore del modello è già stato introdotto nell'anno.</summary>
|
||||
public static bool IsSuperseded(VehicleDef def, int year) => def.SuccessorDef is { } s && s.EraFrom <= year;
|
||||
|
||||
/// <summary>Anno da cui il modello è superato (null se non ha successore).</summary>
|
||||
public static int? SupersededYear(VehicleDef def) => def.SuccessorDef?.EraFrom;
|
||||
|
||||
/// <summary>
|
||||
/// Successore consigliato nell'anno: il più recente della catena dei successori già introdotto e
|
||||
/// ancora in produzione (null se il modello non è superato o nessun successore si può comprare).
|
||||
/// </summary>
|
||||
public static VehicleDef? Recommended(VehicleDef def, int year)
|
||||
{
|
||||
VehicleDef? best = null;
|
||||
for (var s = def.SuccessorDef; s is not null && s.EraFrom <= year; s = s.SuccessorDef)
|
||||
{
|
||||
if (InProduction(s, year)) best = s;
|
||||
}
|
||||
return best;
|
||||
}
|
||||
|
||||
/// <summary>Primo giorno in cui il modello è superato (long.MaxValue se non ha successore).</summary>
|
||||
public static long SupersededDay(Calendar calendar, VehicleDef def) =>
|
||||
def.SuccessorDef is { } s ? (long)(s.EraFrom - calendar.StartYear) * calendar.DaysPerYear : long.MaxValue;
|
||||
|
||||
/// <summary>Anni da quando il veicolo è superato (dal giorno d'acquisto se è successivo); 0 se non lo è.</summary>
|
||||
public static double YearsSuperseded(World w, Vehicle v)
|
||||
{
|
||||
long since = SupersededDay(w.Calendar, v.Def);
|
||||
long today = w.Clock.Day;
|
||||
if (today < since) return 0;
|
||||
return (today - Math.Max(v.BoughtDay, since)) / (double)w.Calendar.DaysPerYear;
|
||||
}
|
||||
|
||||
/// <summary>Residuo del valore del veicolo oggi (frazione del prezzo di listino).</summary>
|
||||
public static double Residual(World w, Vehicle v) => Residual(w.Data, w.Calendar, v.Def, v.BoughtDay, w.Clock.Day);
|
||||
|
||||
/// <summary>Residuo del valore di un veicolo del modello comprato in <paramref name="boughtDay"/>, al giorno <paramref name="today"/>.</summary>
|
||||
public static double Residual(GameData d, Calendar calendar, VehicleDef def, long boughtDay, long today)
|
||||
{
|
||||
double daysPerYear = calendar.DaysPerYear;
|
||||
double floor = d.Balance.Finance.BookValueFloor;
|
||||
double age = (today - boughtDay) / daysPerYear;
|
||||
long since = SupersededDay(calendar, def);
|
||||
if (today < since) return Math.Max(floor, 1 - age / def.LifeYears);
|
||||
var o = d.Obsolescence;
|
||||
double years = (today - Math.Max(boughtDay, since)) / daysPerYear;
|
||||
double effectiveAge = age + (o.DepreciationSpeed - 1) * years;
|
||||
return Math.Max(floor, (1 - o.ImmediateValueLoss) * (1 - effectiveAge / def.LifeYears));
|
||||
}
|
||||
|
||||
/// <summary>Valore di libro del veicolo in centesimi: prezzo × residuo (voce «veicoli» del patrimonio).</summary>
|
||||
public static long BookValueCents(World w, Vehicle v) => (long)(v.Def.Price * Residual(w, v));
|
||||
|
||||
/// <summary>Condizione media dei componenti come frazione (1 se il veicolo non ne ha).</summary>
|
||||
public static double AverageCondition(Vehicle v) => v.Components.Length == 0 ? 1 : v.Components.Average() / 100;
|
||||
|
||||
/// <summary>Valore di rivendita (mercato dell'usato): prezzo × residuo × condizione media.</summary>
|
||||
public static Money ResaleValue(World w, Vehicle v) => new Money(v.Def.Price) * (Residual(w, v) * AverageCondition(v));
|
||||
|
||||
/// <summary>Moltiplicatore dei costi di manutenzione del modello nell'anno: maintenanceCostFactor se superato, altrimenti 1.</summary>
|
||||
public static double MaintenanceCostFactor(GameData d, VehicleDef def, int year) =>
|
||||
IsSuperseded(def, year) ? d.Obsolescence.MaintenanceCostFactor : 1;
|
||||
|
||||
/// <summary>
|
||||
/// Veicoli del treno da rinnovare oggi, in ordine di composizione: quelli superati con un successore
|
||||
/// consigliato in produzione, con il prezzo del successore e la rivendita del vecchio.
|
||||
/// </summary>
|
||||
public static List<RenewalItem> RenewalPlan(World w, Train t)
|
||||
{
|
||||
var list = new List<RenewalItem>();
|
||||
int year = w.Clock.Year;
|
||||
foreach (var id in t.Vehicles)
|
||||
{
|
||||
var v = w.Vehicles[id.Value];
|
||||
if (!IsSuperseded(v.Def, year) || Recommended(v.Def, year) is not { } next) continue;
|
||||
list.Add(new RenewalItem(v, next, new Money(next.Price), ResaleValue(w, v)));
|
||||
}
|
||||
return list;
|
||||
}
|
||||
|
||||
/// <summary>Spesa netta di un rinnovo: prezzi dei successori meno le rivendite (può essere negativa).</summary>
|
||||
public static Money NetCost(List<RenewalItem> plan)
|
||||
{
|
||||
long cents = 0;
|
||||
foreach (var item in plan) cents += item.Price.Cents - item.Resale.Cents;
|
||||
return new Money(cents);
|
||||
}
|
||||
|
||||
/// <summary>Indice in maintenance.json dell'intervento con effetto «renew» (il validatore ne garantisce uno).</summary>
|
||||
public static int RenewalIntervention(GameData d) => d.Maintenance.Interventions.FindIndex(i => i.Effect == InterventionEffect.Renew);
|
||||
|
||||
/// <summary>Spesa complessiva del rinnovo del treno oggi: successori − rivendite + lavoro dell'officina.</summary>
|
||||
public static Money RenewalCost(World w, Train t, List<RenewalItem> plan) =>
|
||||
NetCost(plan) + Fleet.CostOf(w, t, w.Data.Maintenance.Interventions[RenewalIntervention(w.Data)], Fleet.PolicyOf(w, t));
|
||||
|
||||
/// <summary>Vero se il treno ha un rinnovo prenotato o in officina.</summary>
|
||||
public static bool RenewalBooked(World w, Train t) => t.PlannedIntervention >= 0 && t.PlannedIntervention == RenewalIntervention(w.Data);
|
||||
|
||||
/// <summary>
|
||||
/// Spesa impegnata dal rinnovo prenotato del treno e non ancora pagata: la spesa di oggi (se positiva)
|
||||
/// finché i lavori non partono. All'avvio i veicoli si sostituiscono e il piano si svuota, quindi un
|
||||
/// rinnovo già pagato non impegna più nulla.
|
||||
/// </summary>
|
||||
public static Money Commitment(World w, Train t)
|
||||
{
|
||||
if (t.Removed || !RenewalBooked(w, t)) return Money.Zero;
|
||||
var plan = RenewalPlan(w, t);
|
||||
if (plan.Count == 0) return Money.Zero;
|
||||
var cost = RenewalCost(w, t, plan);
|
||||
return cost.IsPositive ? cost : Money.Zero;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Spesa impegnata dai rinnovi prenotati della compagnia e non ancora avviati, escluso eventualmente
|
||||
/// un treno: va tolta dalla cassa prima di prenotarne un altro o di investire (ADR 0020).
|
||||
/// </summary>
|
||||
public static Money Committed(World w, CompanyId company, Train? except = null)
|
||||
{
|
||||
long cents = 0;
|
||||
foreach (var t in w.Trains)
|
||||
{
|
||||
if (t != except && t.Owner == company) cents += Commitment(w, t).Cents;
|
||||
}
|
||||
return new Money(cents);
|
||||
}
|
||||
|
||||
/// <summary>Vero se il modello <paramref name="next"/> non ha sforzo di trazione, potenza o velocità massima inferiori a <paramref name="old"/>.</summary>
|
||||
public static bool NoWorseThan(VehicleDef next, VehicleDef old) =>
|
||||
next.TractiveEffortKn >= old.TractiveEffortKn && next.PowerKw >= old.PowerKw && next.MaxSpeedKmh >= old.MaxSpeedKmh;
|
||||
|
||||
/// <summary>
|
||||
/// Vero se il rinnovo non peggiora le prestazioni del treno: sforzo di trazione, potenza, velocità
|
||||
/// massima e rapporto potenza/massa restano almeno quelli di oggi. Le IA rinnovano solo così; il
|
||||
/// giocatore vede il successore con le sue prestazioni e decide da sé.
|
||||
/// </summary>
|
||||
public static bool KeepsPerformance(World w, Train t, List<RenewalItem> plan)
|
||||
{
|
||||
double te = 0, power = 0, mass = 0, vmax = double.MaxValue;
|
||||
double te2 = 0, power2 = 0, mass2 = 0, vmax2 = double.MaxValue;
|
||||
foreach (var id in t.Vehicles)
|
||||
{
|
||||
var def = w.Vehicles[id.Value].Def;
|
||||
var next = def;
|
||||
foreach (var item in plan)
|
||||
{
|
||||
if (item.Old.Id == id) next = item.Successor;
|
||||
}
|
||||
te += def.TractiveEffortKn; power += def.PowerKw; mass += def.MassT; vmax = Math.Min(vmax, def.MaxSpeedKmh);
|
||||
te2 += next.TractiveEffortKn; power2 += next.PowerKw; mass2 += next.MassT; vmax2 = Math.Min(vmax2, next.MaxSpeedKmh);
|
||||
}
|
||||
if (mass <= 0 || mass2 <= 0) return true;
|
||||
const double eps = 1e-9;
|
||||
return te2 + eps >= te && power2 + eps >= power && vmax2 + eps >= vmax && power2 / mass2 + eps >= power / mass;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Rinnovo in officina (intervento con effetto «renew»), all'avvio dei lavori: ogni veicolo del piano
|
||||
/// si vende al valore di rivendita (voce «vendita di treni») e al suo posto, nella stessa posizione
|
||||
/// della composizione, entra un veicolo nuovo del successore consigliato (voce «acquisto di treni»).
|
||||
/// I veicoli venduti restano nell'elenco con <c>Sold</c>, come quelli di <c>SellVehicle</c>.
|
||||
/// Il controllo della cassa spetta a chi chiama. Restituisce quanti veicoli sono stati sostituiti.
|
||||
/// </summary>
|
||||
public static int Renew(World w, Train t) => Renew(w, t, RenewalPlan(w, t));
|
||||
|
||||
/// <summary>Rinnovo con un piano già calcolato oggi (vedi <see cref="Renew(World, Train)"/>).</summary>
|
||||
public static int Renew(World w, Train t, List<RenewalItem> plan)
|
||||
{
|
||||
if (plan.Count == 0) return 0;
|
||||
var owner = Account.Of(t.Owner);
|
||||
foreach (var item in plan)
|
||||
{
|
||||
var old = item.Old;
|
||||
int index = t.Vehicles.IndexOf(old.Id);
|
||||
var fresh = new Vehicle
|
||||
{
|
||||
Id = new VehicleId(w.Vehicles.Count),
|
||||
Def = item.Successor,
|
||||
Owner = old.Owner,
|
||||
BoughtDay = w.Clock.Day,
|
||||
Train = t.Id,
|
||||
};
|
||||
Fleet.InitVehicle(w.Data, fresh, w.Clock.Day);
|
||||
w.Vehicles.Add(fresh);
|
||||
old.Sold = true;
|
||||
old.Train = TrainId.None;
|
||||
old.Depot = DepotId.None;
|
||||
t.Vehicles[index] = fresh.Id;
|
||||
if (item.Resale.IsPositive) w.Money.Transfer(Account.External, owner, item.Resale, LedgerEntry.VehicleSale);
|
||||
w.Money.Transfer(owner, Account.External, item.Price, LedgerEntry.VehiclePurchase);
|
||||
}
|
||||
w.NextIds.Vehicle = w.Vehicles.Count;
|
||||
RailCommandHandlers.RecomputeTrain(w, t);
|
||||
w.LineGraphs.Touch();
|
||||
return plan.Count;
|
||||
}
|
||||
}
|
||||
@@ -56,6 +56,9 @@ public sealed class ClientWorld(GameData data)
|
||||
/// <summary>Quadro delle finanze (F6), su richiesta: lo usa il pannello «Finanze».</summary>
|
||||
public FinanceReport? Finance { get; private set; }
|
||||
|
||||
/// <summary>Quadro del rinnovo della flotta (F6, ADR 0020), su richiesta: lo usano i pannelli Treni e Officine.</summary>
|
||||
public FleetReport? Fleet { get; private set; }
|
||||
|
||||
/// <summary>Contatore dei listini ricevuti (per aggiornare il pannello della borsa).</summary>
|
||||
public int TapeVersion { get; private set; }
|
||||
|
||||
@@ -148,6 +151,10 @@ public sealed class ClientWorld(GameData data)
|
||||
Finance = m;
|
||||
DetailVersion++;
|
||||
return true;
|
||||
case FleetReport m:
|
||||
Fleet = m;
|
||||
DetailVersion++;
|
||||
return true;
|
||||
case MaintenanceAlert m:
|
||||
Alerts.Insert(0, m);
|
||||
if (Alerts.Count > AlertCapacity) Alerts.RemoveAt(Alerts.Count - 1);
|
||||
@@ -170,6 +177,7 @@ public sealed class ClientWorld(GameData data)
|
||||
Market = null;
|
||||
Climb = null;
|
||||
Finance = null;
|
||||
Fleet = null;
|
||||
Alerts.Clear();
|
||||
Summary = m.Summary;
|
||||
SessionId = m.SessionId;
|
||||
|
||||
@@ -47,6 +47,8 @@ public enum MessageId : ushort
|
||||
ClimbReport = 134,
|
||||
/// <summary>Quadro delle finanze: conto economico per voce, rating spiegato, prestiti, bancarotta (F6).</summary>
|
||||
FinanceReport = 135,
|
||||
/// <summary>Quadro del rinnovo della flotta: ere, veicoli superati, successori, valori (F6).</summary>
|
||||
FleetReport = 136,
|
||||
}
|
||||
|
||||
/// <summary>Messaggio del protocollo: si serializza a mano, campo per campo.</summary>
|
||||
|
||||
@@ -243,6 +243,8 @@ public enum DetailKind : byte
|
||||
Climb = 8,
|
||||
/// <summary>Quadro delle finanze (risposta FinanceReport, F6; Id ignorato).</summary>
|
||||
Finance = 9,
|
||||
/// <summary>Quadro del rinnovo della flotta (risposta FleetReport, F6, ADR 0020; Id ignorato).</summary>
|
||||
Fleet = 10,
|
||||
}
|
||||
|
||||
/// <summary>Chiede al server un dettaglio che non viaggia con le entità (aggiunto in F4).</summary>
|
||||
|
||||
@@ -0,0 +1,161 @@
|
||||
using RailEnterprise.Core.Common;
|
||||
|
||||
namespace RailEnterprise.Protocol.Messages;
|
||||
|
||||
// Messaggi della fase F6: ere e obsolescenza dei veicoli (ADR 0020). Il quadro del rinnovo della flotta
|
||||
// arriva su richiesta (RequestDetail con DetailKind.Fleet) ed è calcolato dal server con FleetOutlook: il
|
||||
// client lo mostra com'è, senza calcolare età, valori, successori o modelli in produzione.
|
||||
|
||||
/// <summary>
|
||||
/// Veicolo della compagnia per il rinnovo: modello, treno o deposito, età e vita utile, condizione media
|
||||
/// (0–1), produzione, obsolescenza (anno da cui è superato, 0 se non ha successore), successore consigliato
|
||||
/// ("" se non superato o senza successore in produzione), valore di libro e di rivendita, moltiplicatore dei
|
||||
/// costi di manutenzione.
|
||||
/// </summary>
|
||||
public sealed class FleetVehicleInfo
|
||||
{
|
||||
public int Vehicle { get; init; }
|
||||
public string Type { get; init; } = "";
|
||||
public int Train { get; init; } = -1;
|
||||
public int Depot { get; init; } = -1;
|
||||
public float AgeYears { get; init; }
|
||||
public int LifeYears { get; init; }
|
||||
public float Condition { get; init; }
|
||||
public bool InProduction { get; init; }
|
||||
public bool Superseded { get; init; }
|
||||
public int SupersededYear { get; init; }
|
||||
public string Successor { get; init; } = "";
|
||||
public Money BookValue { get; init; }
|
||||
public Money Resale { get; init; }
|
||||
public float MaintenanceFactor { get; init; }
|
||||
|
||||
public void Write(ref SpanWriter w)
|
||||
{
|
||||
w.I32(Vehicle); w.String(Type); w.I32(Train); w.I32(Depot); w.F32(AgeYears); w.I32(LifeYears); w.F32(Condition);
|
||||
w.Bool(InProduction); w.Bool(Superseded); w.I32(SupersededYear); w.String(Successor);
|
||||
w.Money(BookValue); w.Money(Resale); w.F32(MaintenanceFactor);
|
||||
w.Flags(0);
|
||||
}
|
||||
|
||||
public static FleetVehicleInfo Read(ref SpanReader r)
|
||||
{
|
||||
var m = new FleetVehicleInfo
|
||||
{
|
||||
Vehicle = r.I32(), Type = r.String(), Train = r.I32(), Depot = r.I32(), AgeYears = r.F32(), LifeYears = r.I32(), Condition = r.F32(),
|
||||
InProduction = r.Bool(), Superseded = r.Bool(), SupersededYear = r.I32(), Successor = r.String(),
|
||||
BookValue = r.Money(), Resale = r.Money(), MaintenanceFactor = r.F32(),
|
||||
};
|
||||
r.Flags();
|
||||
return m;
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Modello in produzione per il catalogo d'acquisto: superato o no, anno da cui lo è (0 se non ha
|
||||
/// successore), successore consigliato, ultimo anno di produzione (0 se non previsto).
|
||||
/// </summary>
|
||||
public sealed class VehicleModelInfo
|
||||
{
|
||||
public string Type { get; init; } = "";
|
||||
public bool Superseded { get; init; }
|
||||
public int SupersededYear { get; init; }
|
||||
public string Successor { get; init; } = "";
|
||||
public int LastYear { get; init; }
|
||||
|
||||
public void Write(ref SpanWriter w)
|
||||
{
|
||||
w.String(Type); w.Bool(Superseded); w.I32(SupersededYear); w.String(Successor); w.I32(LastYear);
|
||||
w.Flags(0);
|
||||
}
|
||||
|
||||
public static VehicleModelInfo Read(ref SpanReader r)
|
||||
{
|
||||
var m = new VehicleModelInfo { Type = r.String(), Superseded = r.Bool(), SupersededYear = r.I32(), Successor = r.String(), LastYear = r.I32() };
|
||||
r.Flags();
|
||||
return m;
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Treno con veicoli superati da rinnovare: quanti, spesa netta (successori − rivendite + lavoro), se la cassa
|
||||
/// basta al netto degli altri rinnovi prenotati e se il rinnovo è già prenotato (in viaggio o in coda all'officina).
|
||||
/// </summary>
|
||||
public sealed class RenewalTrainInfo
|
||||
{
|
||||
public int Train { get; init; }
|
||||
public int Vehicles { get; init; }
|
||||
public Money NetCost { get; init; }
|
||||
public bool Affordable { get; init; }
|
||||
public bool Booked { get; init; }
|
||||
|
||||
public void Write(ref SpanWriter w)
|
||||
{
|
||||
w.I32(Train); w.I32(Vehicles); w.Money(NetCost); w.Bool(Affordable); w.Bool(Booked);
|
||||
w.Flags(0);
|
||||
}
|
||||
|
||||
public static RenewalTrainInfo Read(ref SpanReader r)
|
||||
{
|
||||
var m = new RenewalTrainInfo { Train = r.I32(), Vehicles = r.I32(), NetCost = r.Money(), Affordable = r.Bool(), Booked = r.Bool() };
|
||||
r.Flags();
|
||||
return m;
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Quadro del rinnovo della flotta della compagnia della sessione (F6, ADR 0020): era in corso e prossima
|
||||
/// (con l'anno; "" e 0 all'ultima), veicoli con età, obsolescenza, successore e valori, catalogo dei
|
||||
/// modelli in produzione, treni da rinnovare con l'intervento «renewal».
|
||||
/// </summary>
|
||||
public sealed class FleetReport : IMessage
|
||||
{
|
||||
public MessageId Id => MessageId.FleetReport;
|
||||
public long Day { get; init; }
|
||||
public int Company { get; init; }
|
||||
public int Year { get; init; }
|
||||
public string Era { get; init; } = "";
|
||||
public string NextEra { get; init; } = "";
|
||||
public int NextEraYear { get; init; }
|
||||
/// <summary>Id dell'intervento di rinnovo in maintenance.json (per ScheduleService).</summary>
|
||||
public string RenewalIntervention { get; init; } = "";
|
||||
public Money BookValueTotal { get; init; }
|
||||
public List<FleetVehicleInfo> Vehicles { get; init; } = [];
|
||||
public List<VehicleModelInfo> Models { get; init; } = [];
|
||||
public List<RenewalTrainInfo> Trains { get; init; } = [];
|
||||
|
||||
public void Write(ref SpanWriter w)
|
||||
{
|
||||
w.I64(Day); w.I32(Company); w.I32(Year); w.String(Era); w.String(NextEra); w.I32(NextEraYear); w.String(RenewalIntervention);
|
||||
w.Money(BookValueTotal);
|
||||
w.Count(Vehicles.Count);
|
||||
foreach (var v in Vehicles) v.Write(ref w);
|
||||
w.Count(Models.Count);
|
||||
foreach (var m in Models) m.Write(ref w);
|
||||
w.Count(Trains.Count);
|
||||
foreach (var t in Trains) t.Write(ref w);
|
||||
w.Flags(0);
|
||||
}
|
||||
|
||||
public static FleetReport Read(ref SpanReader r)
|
||||
{
|
||||
long day = r.I64();
|
||||
int company = r.I32(), year = r.I32();
|
||||
string era = r.String(), next = r.String();
|
||||
int nextYear = r.I32();
|
||||
string renewal = r.String();
|
||||
var book = r.Money();
|
||||
var vehicles = new List<FleetVehicleInfo>();
|
||||
for (int n = r.Count(), i = 0; i < n; i++) vehicles.Add(FleetVehicleInfo.Read(ref r));
|
||||
var models = new List<VehicleModelInfo>();
|
||||
for (int n = r.Count(), i = 0; i < n; i++) models.Add(VehicleModelInfo.Read(ref r));
|
||||
var trains = new List<RenewalTrainInfo>();
|
||||
for (int n = r.Count(), i = 0; i < n; i++) trains.Add(RenewalTrainInfo.Read(ref r));
|
||||
var m = new FleetReport
|
||||
{
|
||||
Day = day, Company = company, Year = year, Era = era, NextEra = next, NextEraYear = nextYear, RenewalIntervention = renewal,
|
||||
BookValueTotal = book, Vehicles = vehicles, Models = models, Trains = trains,
|
||||
};
|
||||
r.Flags();
|
||||
return m;
|
||||
}
|
||||
}
|
||||
@@ -34,6 +34,7 @@ public static class MessageCodec
|
||||
MessageId.MarketReport => MarketReport.Read(ref r),
|
||||
MessageId.ClimbReport => ClimbReport.Read(ref r),
|
||||
MessageId.FinanceReport => FinanceReport.Read(ref r),
|
||||
MessageId.FleetReport => FleetReport.Read(ref r),
|
||||
MessageId.MarketTape => MarketTape.Read(ref r),
|
||||
MessageId.CommandResult => CommandResultMessage.Read(ref r),
|
||||
MessageId.Notification => Notification.Read(ref r),
|
||||
|
||||
@@ -667,6 +667,9 @@ public sealed class GameHost : IDisposable
|
||||
case DetailKind.Finance:
|
||||
if (s.Company.IsValid && s.Company.Value < w.Companies.Count) s.Send(Projection.Finance(w, s.Company));
|
||||
break;
|
||||
case DetailKind.Fleet:
|
||||
if (s.Company.IsValid && s.Company.Value < w.Companies.Count) s.Send(Projection.FleetRenewal(w, s.Company));
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -625,6 +625,32 @@ public static class Projection
|
||||
};
|
||||
}
|
||||
|
||||
/// <summary>Quadro del rinnovo della flotta per la compagnia della sessione (FleetOutlook, ADR 0020).</summary>
|
||||
public static FleetReport FleetRenewal(World w, CompanyId company)
|
||||
{
|
||||
var report = FleetOutlook.Build(w, company);
|
||||
var interventions = w.Data.Maintenance.Interventions;
|
||||
return new FleetReport
|
||||
{
|
||||
Day = report.Day, Company = report.Company.Value, Year = report.Year, Era = report.Era.Id,
|
||||
NextEra = report.NextEra?.Id ?? "", NextEraYear = report.NextEra?.From ?? 0,
|
||||
RenewalIntervention = interventions.First(i => i.Effect == InterventionEffect.Renew).Id,
|
||||
BookValueTotal = report.BookValueTotal,
|
||||
Vehicles = report.Vehicles.Select(v => new FleetVehicleInfo
|
||||
{
|
||||
Vehicle = v.Id.Value, Type = v.Def.Id, Train = v.Train.Value, Depot = v.Depot.Value, AgeYears = (float)v.AgeYears,
|
||||
LifeYears = v.Def.LifeYears, Condition = (float)v.Condition, InProduction = v.InProduction, Superseded = v.Superseded,
|
||||
SupersededYear = v.SupersededYear ?? 0, Successor = v.Successor?.Id ?? "", BookValue = v.BookValue, Resale = v.ResaleValue,
|
||||
MaintenanceFactor = (float)v.MaintenanceFactor,
|
||||
}).ToList(),
|
||||
Models = report.Models.Select(m => new VehicleModelInfo
|
||||
{
|
||||
Type = m.Def.Id, Superseded = m.Superseded, SupersededYear = m.SupersededYear ?? 0, Successor = m.Successor?.Id ?? "", LastYear = m.LastYear ?? 0,
|
||||
}).ToList(),
|
||||
Trains = report.Trains.Select(t => new RenewalTrainInfo { Train = t.Train.Value, Vehicles = t.Vehicles, NetCost = t.NetCost, Affordable = t.Affordable, Booked = t.Booked }).ToList(),
|
||||
};
|
||||
}
|
||||
|
||||
/// <summary>Evento del mondo in corso → record del protocollo (ADR 0017).</summary>
|
||||
public static WorldEventInfo WorldEvent(ActiveWorldEvent e) => new()
|
||||
{
|
||||
|
||||
@@ -0,0 +1,511 @@
|
||||
using System.Text.Json.Nodes;
|
||||
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.Ai;
|
||||
using RailEnterprise.Core.Simulation.Scenarios;
|
||||
using RailEnterprise.Core.Simulation.Systems;
|
||||
using RailEnterprise.Protocol;
|
||||
using RailEnterprise.Protocol.Messages;
|
||||
using RailEnterprise.Server;
|
||||
using RailEnterprise.Tests.Harness;
|
||||
using RailEnterprise.Tests.Rail;
|
||||
using RailEnterprise.Tests.Scenarios;
|
||||
|
||||
namespace RailEnterprise.Tests.Economy;
|
||||
|
||||
/// <summary>Ere, novità tecnologiche, obsolescenza e rinnovo della flotta (F6, ADR 0020).</summary>
|
||||
public static class ErasTests
|
||||
{
|
||||
private static readonly Vec2 DepotPos = RailFixture.K(2.6, 4.4);
|
||||
|
||||
/// <summary>Valdoria che comincia nell'anno indicato, con un deposito e l'id del deposito.</summary>
|
||||
private static (RailFixture F, int Depot) ValdoriaIn(int year, GameData? data = null)
|
||||
{
|
||||
var json = JsonNode.Parse(File.ReadAllText(ScenarioHelper.PathOf("valdoria")))!;
|
||||
json["startYear"] = year;
|
||||
var s = ScenarioLoader.Load(data ?? TestData.Data, json.ToJsonString());
|
||||
var f = new RailFixture(s.World, s);
|
||||
int depot = f.Ok(new BuildDepotCommand(DepotPos, "small", "Deposito di prova"));
|
||||
return (f, depot);
|
||||
}
|
||||
|
||||
private static int CountTechnology(IEnumerable<GameEvent> events) => events.Count(e => e.Kind == EventKind.Technology);
|
||||
|
||||
private static void AssertInvariants(World w, string when)
|
||||
{
|
||||
Assert.Equal(0L, w.MoneyBalanceSum(), $"denaro {when}");
|
||||
for (int g = 0; g < w.Data.GoodCount; g++)
|
||||
Assert.Equal(w.Goods.ExpectedStock(g), w.TotalStock(g), $"merce {w.Data.Goods[g].Id} {when}");
|
||||
}
|
||||
|
||||
[Test(Description = "Sblocchi per anno letti dai dati: era in corso, novità, fuori produzione, superati e testo della notizia")]
|
||||
public static void UnlocksFollowTheYear()
|
||||
{
|
||||
var d = TestData.Data;
|
||||
Assert.Equal("steam", EraSystem.CurrentEra(d, 1924).Id);
|
||||
Assert.Equal("diesel", EraSystem.CurrentEra(d, 1925).Id);
|
||||
Assert.Equal("electric", EraSystem.NextEra(d, 1925)!.Id);
|
||||
Assert.True(EraSystem.NextEra(d, 1990) is null, "dopo l'ultima era non ce n'è un'altra");
|
||||
|
||||
var u1878 = EraSystem.Unlocks(d, 1878);
|
||||
Assert.True(u1878.Any(u => u.Kind == TechKind.Vehicle && u.Id == "loco_steam_1878"), "1878: Vittoria 2-8-0");
|
||||
Assert.Equal("loco_steam_1850", EraSystem.NewlySuperseded(d, 1878).Single().Id);
|
||||
var u1925 = EraSystem.Unlocks(d, 1925);
|
||||
Assert.True(u1925.Any(u => u.Kind == TechKind.Traction && u.Id == "diesel"), "1925: trazione diesel");
|
||||
Assert.True(u1925.Any(u => u.Kind == TechKind.Vehicle && u.Id == "loco_diesel_1925"), "1925: Aquila D1");
|
||||
var u1950 = EraSystem.Unlocks(d, 1950);
|
||||
Assert.True(u1950.Any(u => u.Kind == TechKind.Electrification), "1950: elettrificazione");
|
||||
Assert.True(u1950.Any(u => u.Kind == TechKind.BridgeType && u.Id == "concrete"), "1950: ponti in cemento armato");
|
||||
Assert.True(u1950.Any(u => u.Kind == TechKind.TunnelLimit), "1950: gallerie più lunghe");
|
||||
Assert.Equal("loco_steam_1850", EraSystem.Retired(d, 1906).Single().Id);
|
||||
|
||||
string text = EraSystem.NewsText(d, 1925)!;
|
||||
Assert.True(text.StartsWith("Inizia l'Era diesel (1925)", StringComparison.Ordinal), text);
|
||||
Assert.True(text.Contains("Aquila D1", StringComparison.Ordinal) && text.Contains("Freccia 4-6-2 (successore Aquila D1)", StringComparison.Ordinal), text);
|
||||
Assert.True(EraSystem.NewsText(d, 1878)!.StartsWith("Novità del 1878", StringComparison.Ordinal));
|
||||
Assert.True(EraSystem.NewsText(d, 1906)!.Contains("fuori produzione: Ardita 2-6-0", StringComparison.Ordinal));
|
||||
Assert.True(EraSystem.NewsText(d, 1851) is null, "un anno senza novità non dà notizie");
|
||||
|
||||
// nessun elenco scritto a mano: un modello aggiunto ai dati entra nella notizia del suo anno
|
||||
var files = MemoryDataSource.Snapshot(TestData.Source);
|
||||
var vehicles = JsonNode.Parse(files["vehicles.json"])!;
|
||||
var copy = JsonNode.Parse(vehicles["vehicles"]![0]!.ToJsonString())!;
|
||||
copy["id"] = "loco_steam_1851";
|
||||
copy["name_it"] = "Prova 1851";
|
||||
copy["eraFrom"] = 1851;
|
||||
copy.AsObject().Remove("successor");
|
||||
vehicles["vehicles"]!.AsArray().Add(copy);
|
||||
files["vehicles.json"] = vehicles.ToJsonString();
|
||||
var altered = GameData.Load(new MemoryDataSource(files));
|
||||
Assert.True(EraSystem.NewsText(altered, 1851)!.Contains("locomotiva Prova 1851", StringComparison.Ordinal));
|
||||
}
|
||||
|
||||
[Test(Description = "Il validatore rifiuta successori sconosciuti, di un'altra categoria o introdotti prima")]
|
||||
public static void SuccessorValidation()
|
||||
{
|
||||
static string? Error(Action<JsonNode> change)
|
||||
{
|
||||
var files = MemoryDataSource.Snapshot(TestData.Source);
|
||||
var vehicles = JsonNode.Parse(files["vehicles.json"])!;
|
||||
change(vehicles["vehicles"]!);
|
||||
files["vehicles.json"] = vehicles.ToJsonString();
|
||||
try
|
||||
{
|
||||
GameData.Load(new MemoryDataSource(files));
|
||||
return null;
|
||||
}
|
||||
catch (DataValidationException ex)
|
||||
{
|
||||
return ex.Message;
|
||||
}
|
||||
}
|
||||
JsonNode Find(JsonNode list, string id) => list.AsArray().First(v => (string)v!["id"]! == id)!;
|
||||
Assert.True(Error(l => Find(l, "loco_steam_1850")["successor"] = "loco_inesistente") is { } e1 && e1.Contains("sconosciuto", StringComparison.Ordinal));
|
||||
Assert.True(Error(l => Find(l, "loco_steam_1850")["successor"] = "wagon_hopper") is { } e2 && e2.Contains("categoria", StringComparison.Ordinal));
|
||||
Assert.True(Error(l => Find(l, "loco_steam_1878")["successor"] = "loco_steam_1850") is { } e3 && e3.Contains("dopo", StringComparison.Ordinal));
|
||||
Assert.True(Error(l => Find(l, "loco_diesel_1925")["successor"] = "loco_electric_1950") is { } e4 && e4.Contains("elettrificata", StringComparison.Ordinal));
|
||||
}
|
||||
|
||||
[Test(Description = "La notizia del passaggio d'anno esce una volta sola, anche salvando prima o dopo, e la Cronaca la registra")]
|
||||
public static void EraNewsOnceAcrossSaves()
|
||||
{
|
||||
var (f, _) = ValdoriaIn(1877);
|
||||
var w = f.W;
|
||||
int dpy = w.Calendar.DaysPerYear;
|
||||
w.RunTicks((long)dpy * w.Calendar.TicksPerDay - 1 - w.Clock.Tick);
|
||||
Assert.Equal(1877, w.Clock.Year);
|
||||
Assert.Equal(0, CountTechnology(w.Events.Drain()), "nessuna notizia nel 1877");
|
||||
var before = SaveFile.Load(TestData.Data, SaveFile.Save(w, "test"));
|
||||
w.RunDays(2);
|
||||
before.RunDays(2);
|
||||
var news = w.Events.Drain().Where(e => e.Kind == EventKind.Technology).ToList();
|
||||
Assert.Equal(1, news.Count, "una notizia nel tick del 1° gennaio");
|
||||
Assert.Equal(1, CountTechnology(before.Events.Drain()), "anche dal salvataggio fatto il 31 dicembre");
|
||||
Assert.True(news[0].Text.Contains("Vittoria 2-8-0", StringComparison.Ordinal), news[0].Text);
|
||||
Assert.False(news[0].Company.IsValid, "la notizia è per tutte le compagnie");
|
||||
Assert.Equal(StateHasher.Compute(w), StateHasher.Compute(before), "stesso stato passando dal salvataggio");
|
||||
|
||||
var after = SaveFile.Load(TestData.Data, SaveFile.Save(w, "test"));
|
||||
after.RunDays(60);
|
||||
Assert.Equal(0, CountTechnology(after.Events.Drain()), "dopo il caricamento la notizia non si ripete");
|
||||
Assert.Equal(1, after.Player.Milestones.Count(m => m.Text.StartsWith("novità del 1878", StringComparison.Ordinal)), "fatto saliente nella Cronaca");
|
||||
Assert.True(ChronicleReport.Build(after).Highlights.Any(h => h.Contains("Vittoria 2-8-0", StringComparison.Ordinal)), "nella Cronaca");
|
||||
}
|
||||
|
||||
[Test(Description = "Un modello fuori produzione non si compra né compare nel catalogo; i superati sono segnati con il successore")]
|
||||
public static void OutOfProductionIsNotBuyable()
|
||||
{
|
||||
var (f, depot) = ValdoriaIn(1906);
|
||||
var r = f.Do(new BuyVehicleCommand("loco_steam_1850", new DepotId(depot), 1));
|
||||
Assert.Equal(CommandError.EraLocked, r.Error, r.Message);
|
||||
Assert.True(f.Do(new BuyVehicleCommand("loco_steam_1878", new DepotId(depot), 1)).Ok, "il modello del 1878 è ancora in produzione");
|
||||
var report = FleetOutlook.Build(f.W, f.Me);
|
||||
Assert.False(report.Models.Any(m => m.Def.Id == "loco_steam_1850"), "il catalogo nasconde i fuori produzione");
|
||||
var m1878 = report.Models.Single(m => m.Def.Id == "loco_steam_1878");
|
||||
Assert.True(m1878.Superseded, "superato dalla Freccia del 1902");
|
||||
Assert.Equal("loco_steam_1902", m1878.Successor!.Id);
|
||||
Assert.False(report.Models.Single(m => m.Def.Id == "wagon_hopper").Superseded, "un carro senza successore non è superato");
|
||||
Assert.Equal("loco_steam_1902", Obsolescence.Recommended(f.W.Data.Vehicle("loco_steam_1850"), 1906)!.Id,
|
||||
"il successore consigliato salta i modelli fuori produzione della catena");
|
||||
}
|
||||
|
||||
[Test(Description = "Curva del valore: gradino all'arrivo del successore, poi ammortamento più rapido; rivendita = libro × condizione")]
|
||||
public static void ValueCurveOfSupersededModels()
|
||||
{
|
||||
var d = TestData.Data;
|
||||
var (f, depot) = ValdoriaIn(1876);
|
||||
var w = f.W;
|
||||
var cal = w.Calendar;
|
||||
var o = d.Obsolescence;
|
||||
double floor = d.Balance.Finance.BookValueFloor;
|
||||
var loco = d.Vehicle("loco_steam_1850");
|
||||
var wagon = d.Vehicle("wagon_hopper");
|
||||
long obsolete = Obsolescence.SupersededDay(cal, loco);
|
||||
Assert.Equal((long)(1878 - 1876) * cal.DaysPerYear, obsolete);
|
||||
|
||||
double before = Obsolescence.Residual(d, cal, loco, 0, obsolete - 1);
|
||||
double at = Obsolescence.Residual(d, cal, loco, 0, obsolete);
|
||||
Assert.Approx(1 - (obsolete - 1) / (double)cal.DaysPerYear / loco.LifeYears, before, 1e-12, "prima: lineare sulla vita");
|
||||
Assert.Approx((1 - o.ImmediateValueLoss) * (1 - 2.0 / loco.LifeYears), at, 1e-12, "gradino di immediateValueLoss");
|
||||
double oneYear = Obsolescence.Residual(d, cal, loco, 0, obsolete + cal.DaysPerYear);
|
||||
Assert.Approx((1 - o.ImmediateValueLoss) * (1 - (3 + (o.DepreciationSpeed - 1)) / loco.LifeYears), oneYear, 1e-12, "ammortamento più rapido");
|
||||
// pendenza da superato = depreciationSpeed volte quella normale (scalata dal gradino)
|
||||
double normalSlope = 1.0 / loco.LifeYears;
|
||||
Assert.Approx((1 - o.ImmediateValueLoss) * o.DepreciationSpeed * normalSlope, at - oneYear, 1e-12);
|
||||
// un carro senza successore segue la curva di sempre
|
||||
Assert.Approx(1 - 3.0 / wagon.LifeYears, Obsolescence.Residual(d, cal, wagon, 0, obsolete + cal.DaysPerYear), 1e-12);
|
||||
// monotona e mai sotto il minimo, anche per un veicolo comprato dopo l'arrivo del successore
|
||||
foreach (long bought in new[] { 0L, obsolete + 100 })
|
||||
{
|
||||
double last = double.MaxValue;
|
||||
for (long day = bought; day < bought + 40L * cal.DaysPerYear; day += 7)
|
||||
{
|
||||
double r = Obsolescence.Residual(d, cal, loco, bought, day);
|
||||
Assert.True(r <= last + 1e-12 && r >= floor - 1e-12, $"residuo {r} al giorno {day}");
|
||||
last = r;
|
||||
}
|
||||
}
|
||||
Assert.Approx(1 - o.ImmediateValueLoss, Obsolescence.Residual(d, cal, loco, obsolete + 100, obsolete + 100), 1e-12, "nuovo ma già superato");
|
||||
|
||||
// valore di libro, rivendita e SellVehicle sullo stesso residuo
|
||||
int id = f.Do(new BuyVehicleCommand("loco_steam_1850", new DepotId(depot), 1)).Created[0];
|
||||
w.RunDays((int)(obsolete - w.Clock.Day) + 30);
|
||||
var v = w.Vehicles[id];
|
||||
v.Components[0] = 50;
|
||||
double residual = Obsolescence.Residual(w, v);
|
||||
Assert.Equal((long)(loco.Price * residual), Obsolescence.BookValueCents(w, v));
|
||||
var resale = Obsolescence.ResaleValue(w, v);
|
||||
Assert.Equal(new Money(loco.Price) * (residual * Obsolescence.AverageCondition(v)), resale);
|
||||
var cash = w.Player.Cash;
|
||||
Assert.True(f.Do(new SellVehicleCommand(new VehicleId(id))).Ok);
|
||||
Assert.Equal(cash + resale, w.Player.Cash, "SellVehicle incassa la rivendita");
|
||||
AssertInvariants(w, "dopo la vendita");
|
||||
}
|
||||
|
||||
[Test(Description = "La manutenzione di un modello superato costa maintenanceCostFactor volte; gli altri veicoli non cambiano")]
|
||||
public static void SupersededMaintenanceCostsMore()
|
||||
{
|
||||
Money ServiceCost(int year)
|
||||
{
|
||||
var (f, depot) = ValdoriaIn(year);
|
||||
int train = f.Train(depot, "Prova", ("loco_steam_1850", 1), ("wagon_hopper", 3));
|
||||
var w = f.W;
|
||||
var t = w.Trains[train];
|
||||
var def = w.Data.Maintenance.Interventions[w.Data.Maintenance.InterventionIndex("service")];
|
||||
return Fleet.CostOf(w, t, def, Fleet.PolicyOf(w, t));
|
||||
}
|
||||
var d = TestData.Data;
|
||||
var service = d.Maintenance.Interventions[d.Maintenance.InterventionIndex("service")];
|
||||
long loco = d.Vehicle("loco_steam_1850").Price, wagon = d.Vehicle("wagon_hopper").Price;
|
||||
Assert.Equal(Money.FromCentsRounded((loco + 3.0 * wagon) * service.CostShare), ServiceCost(1877), "prima del successore");
|
||||
Assert.Equal(Money.FromCentsRounded((loco * d.Obsolescence.MaintenanceCostFactor + 3.0 * wagon) * service.CostShare), ServiceCost(1878),
|
||||
"superato: solo la locomotiva costa di più");
|
||||
}
|
||||
|
||||
[Test(Description = "Valore di libro dei veicoli: una sola fonte per patrimonio, quadro della flotta e stato patrimoniale")]
|
||||
public static void BookValueMatchesNetWorth()
|
||||
{
|
||||
var (f, depot) = ValdoriaIn(1877);
|
||||
var w = f.W;
|
||||
f.Train(depot, "Prova", ("loco_steam_1850", 2), ("coach_worker", 2));
|
||||
w.RunDays(w.Calendar.DaysPerYear + w.Calendar.DaysPerMonth - (int)(w.Clock.Day % w.Calendar.DaysPerMonth));
|
||||
Assert.Equal(1878, w.Clock.Year);
|
||||
Assert.Equal(0L, w.Clock.Day % w.Calendar.DaysPerMonth, "inizio del mese: valori appena aggiornati");
|
||||
long expected = w.Vehicles.Where(v => !v.Sold && v.Owner == f.Me).Sum(v => Obsolescence.BookValueCents(w, v));
|
||||
Assert.Equal(expected, FinanceSystem.BookValues(w)[f.Me.Value][(int)AssetCategory.Vehicles], "FinanceSystem.BookValues");
|
||||
Assert.Equal(expected, w.Player.BookValues[(int)AssetCategory.Vehicles], "voce salvata dal mese");
|
||||
Assert.Equal(new Money(expected), FleetOutlook.Build(w, f.Me).BookValueTotal, "quadro della flotta");
|
||||
var balance = ClimbOutlook.Balance(w.Player);
|
||||
Assert.Equal(new Money(expected), balance.Assets.Single(a => a.Category == AssetCategory.Vehicles).Value, "stato patrimoniale");
|
||||
Assert.Equal(w.Player.NetWorth, w.Player.Cash + w.Player.AssetBookValue + w.Player.PortfolioValue - w.Player.Debt);
|
||||
}
|
||||
|
||||
[Test(Description = "Rinnovo in officina: i veicoli superati si vendono e i successori prendono il loro posto, con denaro e merci in equilibrio")]
|
||||
public static void RenewalReplacesSupersededVehicles()
|
||||
{
|
||||
var (f, depot) = ValdoriaIn(1878);
|
||||
var w = f.W;
|
||||
int fresh = f.Train(depot, "Nuovo", ("loco_steam_1878", 1), ("wagon_hopper", 2));
|
||||
var refused = f.Do(new ScheduleServiceCommand(new TrainId(fresh), "renewal"));
|
||||
Assert.Equal(CommandError.NotAllowed, refused.Error, "niente da rinnovare");
|
||||
|
||||
int train = f.Train(depot, "Vecchio", ("loco_steam_1850", 1), ("wagon_hopper", 2));
|
||||
var t = w.Trains[train];
|
||||
var oldLoco = t.Vehicles[0];
|
||||
var wagons = t.Vehicles.Skip(1).ToList();
|
||||
var plan = Obsolescence.RenewalPlan(w, t);
|
||||
Assert.Equal(1, plan.Count, "solo la locomotiva è superata");
|
||||
Assert.Equal("loco_steam_1878", plan[0].Successor.Id);
|
||||
var renewal = w.Data.Maintenance.Interventions[w.Data.Maintenance.InterventionIndex("renewal")];
|
||||
var outlook = FleetOutlook.Build(w, f.Me).Trains.Single(x => x.Train.Value == train);
|
||||
Assert.Equal(Obsolescence.NetCost(plan) + Fleet.CostOf(w, t, renewal, Fleet.PolicyOf(w, t)), outlook.NetCost);
|
||||
|
||||
var cash = w.Player.Cash;
|
||||
Assert.True(f.Do(new ScheduleServiceCommand(new TrainId(train), "renewal")).Ok);
|
||||
Assert.True(t.InWorkshop, "il treno è già nel deposito: entra subito in officina");
|
||||
Assert.True(f.RunUntil(() => !t.InWorkshop, 30), "rinnovo completato");
|
||||
Assert.True(w.Vehicles[oldLoco.Value].Sold, "la vecchia locomotiva è venduta");
|
||||
var loco = w.Vehicles[t.Vehicles[0].Value];
|
||||
Assert.Equal("loco_steam_1878", loco.Def.Id);
|
||||
Assert.Equal(t.Id, loco.Train);
|
||||
Assert.SequenceEqual(wagons, t.Vehicles.Skip(1), "i carri restano al loro posto");
|
||||
Assert.Approx(loco.Def.PowerKw, t.PowerKw, 1e-9, "caratteristiche del treno ricalcolate");
|
||||
Assert.True(w.Player.Cash < cash, "il rinnovo costa");
|
||||
Assert.Equal(0, Obsolescence.RenewalPlan(w, t).Count, "niente più da rinnovare");
|
||||
Assert.True(t.History.Any(h => h.Intervention == w.Data.Maintenance.InterventionIndex("renewal")), "nello storico della manutenzione");
|
||||
AssertInvariants(w, "dopo il rinnovo");
|
||||
}
|
||||
|
||||
[Test(Description = "Rinnovo deterministico e salvataggio a metà officina: stesso hash e stesso esito, senza nuovo stato (corpo versione 7)")]
|
||||
public static void RenewalIsDeterministicAcrossSaves()
|
||||
{
|
||||
Assert.Equal(7, WorldSerializer.BodyVersion, "ere e obsolescenza non aggiungono stato al salvataggio");
|
||||
(World W, int Train) Start()
|
||||
{
|
||||
var (f, depot) = ValdoriaIn(1878);
|
||||
int train = f.Train(depot, "Vecchio", ("loco_steam_1850", 1), ("coach_worker", 2));
|
||||
Assert.True(f.Do(new ScheduleServiceCommand(new TrainId(train), "renewal")).Ok);
|
||||
f.W.RunDays(1);
|
||||
return (f.W, train);
|
||||
}
|
||||
var (a, train) = Start();
|
||||
var (b, _) = Start();
|
||||
var loaded = SaveFile.Load(TestData.Data, SaveFile.Save(b, "test"));
|
||||
Assert.True(loaded.Trains[train].InWorkshop, "salvato a metà officina");
|
||||
a.RunDays(40);
|
||||
loaded.RunDays(40);
|
||||
Assert.Equal(StateHasher.Compute(a), StateHasher.Compute(loaded));
|
||||
Assert.Equal("loco_steam_1878", loaded.Vehicles[loaded.Trains[train].Vehicles[0].Value].Def.Id);
|
||||
Assert.Equal(0L, loaded.MoneyBalanceSum());
|
||||
}
|
||||
|
||||
[Test(Description = "Il quadro della flotta si proietta nel protocollo e sopravvive al round-trip")]
|
||||
public static void FleetReportRoundTrip()
|
||||
{
|
||||
var (f, depot) = ValdoriaIn(1878);
|
||||
var w = f.W;
|
||||
int train = f.Train(depot, "Vecchio", ("loco_steam_1850", 1), ("wagon_hopper", 1));
|
||||
ulong hash = StateHasher.Compute(w);
|
||||
var report = Projection.FleetRenewal(w, f.Me);
|
||||
Assert.Equal(hash, StateHasher.Compute(w), "il quadro non cambia il mondo");
|
||||
var decoded = (FleetReport)Frame.Decode(Frame.Encode(report));
|
||||
Assert.Equal("steam", decoded.Era);
|
||||
Assert.Equal("diesel", decoded.NextEra);
|
||||
Assert.Equal(1925, decoded.NextEraYear);
|
||||
Assert.Equal("renewal", decoded.RenewalIntervention);
|
||||
Assert.Equal(2, decoded.Vehicles.Count);
|
||||
var loco = decoded.Vehicles.Single(v => v.Type == "loco_steam_1850");
|
||||
Assert.True(loco.Superseded && loco.InProduction);
|
||||
Assert.Equal(1878, loco.SupersededYear);
|
||||
Assert.Equal("loco_steam_1878", loco.Successor);
|
||||
Assert.Equal(train, loco.Train);
|
||||
Assert.Approx(w.Data.Obsolescence.MaintenanceCostFactor, loco.MaintenanceFactor, 1e-6);
|
||||
var v = w.Vehicles[loco.Vehicle];
|
||||
Assert.Equal(Obsolescence.ResaleValue(w, v), loco.Resale);
|
||||
Assert.Equal(new Money(Obsolescence.BookValueCents(w, v)), loco.BookValue);
|
||||
Assert.Equal(decoded.Vehicles.Sum(x => x.BookValue.Cents), decoded.BookValueTotal.Cents);
|
||||
Assert.Equal(train, decoded.Trains.Single().Train);
|
||||
Assert.True(decoded.Models.Single(m => m.Type == "loco_steam_1850").Superseded);
|
||||
Assert.False(decoded.Models.Any(m => m.Type == "loco_diesel_1925"), "non ancora introdotto");
|
||||
}
|
||||
|
||||
private static void SetCash(World w, Company c, Money target)
|
||||
{
|
||||
var delta = target - c.Cash;
|
||||
if (delta.IsPositive) w.Money.Transfer(Account.External, Account.Of(c.Id), delta, LedgerEntry.Other);
|
||||
else if (delta.IsNegative) w.Money.Transfer(Account.Of(c.Id), Account.External, -delta, LedgerEntry.Other);
|
||||
}
|
||||
|
||||
[Test(Description = "Rinnovo: la cassa spesa tra prenotazione e avvio annulla il lavoro senza scoperto; due prenotazioni non impegnano la stessa cassa")]
|
||||
public static void RenewalCashIsCheckedAtStartAndCommitted()
|
||||
{
|
||||
var (f, depot) = ValdoriaIn(1878);
|
||||
var w = f.W;
|
||||
int a = f.Train(depot, "Primo", ("loco_steam_1850", 1), ("wagon_hopper", 1));
|
||||
int b = f.Train(depot, "Secondo", ("loco_steam_1850", 1), ("wagon_hopper", 1));
|
||||
var ta = w.Trains[a];
|
||||
var tb = w.Trains[b];
|
||||
// all'inizio di un giorno: l'officina avvia i lavori solo al giorno dopo
|
||||
w.RunTicks(w.Calendar.TicksPerDay - w.Clock.Tick % w.Calendar.TicksPerDay + 1);
|
||||
var cost = Obsolescence.RenewalCost(w, ta, Obsolescence.RenewalPlan(w, ta));
|
||||
Assert.True(cost.IsPositive, "il rinnovo costa");
|
||||
// cassa per un rinnovo solo: il secondo trova la cassa già impegnata dal primo
|
||||
SetCash(w, w.Player, cost + cost * 0.5);
|
||||
Assert.True(f.Do(new ScheduleServiceCommand(new TrainId(a), "renewal")).Ok);
|
||||
Assert.Equal(cost, Obsolescence.Committed(w, f.Me), "spesa impegnata dal rinnovo prenotato");
|
||||
var outlook = FleetOutlook.Build(w, f.Me);
|
||||
Assert.True(outlook.Trains.Single(x => x.Train.Value == a).Booked, "il primo è prenotato");
|
||||
var second = outlook.Trains.Single(x => x.Train.Value == b);
|
||||
Assert.False(second.Booked, "il secondo no");
|
||||
Assert.False(second.Affordable, "il secondo non è pagabile con la cassa già impegnata");
|
||||
var refused = f.Do(new ScheduleServiceCommand(new TrainId(b), "renewal"));
|
||||
Assert.Equal(CommandError.InsufficientFunds, refused.Error, refused.Message);
|
||||
Assert.True(refused.Message.Contains("impegnati", StringComparison.Ordinal), refused.Message);
|
||||
|
||||
// la cassa si spende altrove prima dell'avvio: il rinnovo si annulla, niente scoperto
|
||||
SetCash(w, w.Player, cost - new Money(1));
|
||||
var oldLoco = ta.Vehicles[0];
|
||||
w.Events.Drain();
|
||||
w.RunDays(2);
|
||||
Assert.False(ta.InWorkshop, "il treno esce dall'officina");
|
||||
Assert.Equal(-1, ta.PlannedIntervention);
|
||||
Assert.Equal(oldLoco, ta.Vehicles[0], "nessun veicolo sostituito");
|
||||
Assert.False(w.Vehicles[oldLoco.Value].Sold);
|
||||
Assert.False(w.Player.Cash.IsNegative, "la cassa non va in scoperto");
|
||||
Assert.Equal(0L, ta.MaintenanceThisYear, "nemmeno il lavoro è pagato");
|
||||
Assert.True(w.Events.Drain().Any(e => e.Severity == EventSeverity.Warning && e.Text.Contains("rinnovo annullato", StringComparison.Ordinal)),
|
||||
"notizia di avviso");
|
||||
Assert.Equal(Money.Zero, Obsolescence.Committed(w, f.Me), "niente più impegnato");
|
||||
|
||||
// con la cassa, il rinnovo si paga all'avvio e poi non impegna più nulla
|
||||
SetCash(w, w.Player, cost * 3);
|
||||
Assert.True(f.Do(new ScheduleServiceCommand(new TrainId(a), "renewal")).Ok);
|
||||
w.RunDays(2);
|
||||
Assert.True(ta.InWorkshop, "lavori in corso");
|
||||
Assert.Equal("loco_steam_1878", w.Vehicles[ta.Vehicles[0].Value].Def.Id, "veicoli sostituiti all'avvio");
|
||||
Assert.Equal(Money.Zero, Obsolescence.Committed(w, f.Me), "spesa già pagata");
|
||||
Assert.True(f.RunUntil(() => !ta.InWorkshop, 30), "rinnovo completato");
|
||||
Assert.True(tb.Vehicles.All(id => !w.Vehicles[id.Value].Sold));
|
||||
AssertInvariants(w, "dopo i rinnovi");
|
||||
}
|
||||
|
||||
[Test(Description = "Un rinnovo che all'avvio non ha più nulla da sostituire si annulla senza far pagare il lavoro")]
|
||||
public static void RenewalWithEmptyPlanAtStartIsCancelled()
|
||||
{
|
||||
// la Vittoria 2-8-0 si produce solo nel 1878: dal 1879 l'Ardita è superata ma senza successore in produzione
|
||||
var files = MemoryDataSource.Snapshot(TestData.Source);
|
||||
var vehicles = JsonNode.Parse(files["vehicles.json"])!;
|
||||
vehicles["vehicles"]!.AsArray().First(v => (string)v!["id"]! == "loco_steam_1878")!["eraTo"] = 1878;
|
||||
files["vehicles.json"] = vehicles.ToJsonString();
|
||||
var data = GameData.Load(new MemoryDataSource(files));
|
||||
var (f, depot) = ValdoriaIn(1878, data);
|
||||
var w = f.W;
|
||||
w.RunDays(w.Calendar.DaysPerYear - 3 - (int)w.Clock.Day);
|
||||
Assert.Equal(1878, w.Clock.Year);
|
||||
// due revisioni generali occupano gli stalli del deposito piccolo oltre la fine dell'anno
|
||||
for (int i = 0; i < w.Network.Depots[depot].Stalls; i++)
|
||||
{
|
||||
int busy = f.Train(depot, $"Occupato {i}", ("loco_steam_1878", 1));
|
||||
Assert.True(f.Do(new ScheduleServiceCommand(new TrainId(busy), "overhaul")).Ok);
|
||||
}
|
||||
int train = f.Train(depot, "Vecchio", ("loco_steam_1850", 1), ("wagon_hopper", 1));
|
||||
var t = w.Trains[train];
|
||||
Assert.Equal(1, Obsolescence.RenewalPlan(w, t).Count, "nel 1878 la Vittoria si compra");
|
||||
Assert.True(f.Do(new ScheduleServiceCommand(new TrainId(train), "renewal")).Ok);
|
||||
var oldLoco = t.Vehicles[0];
|
||||
w.Events.Drain();
|
||||
Assert.True(f.RunUntil(() => !t.InWorkshop, 120), "il rinnovo esce dalla coda");
|
||||
Assert.Equal(1879, w.Clock.Year);
|
||||
Assert.Equal(oldLoco, t.Vehicles[0], "nessun veicolo sostituito");
|
||||
Assert.Equal(0L, t.MaintenanceThisYear, "il lavoro non si paga");
|
||||
Assert.False(t.History.Any(h => h.Intervention == w.Data.Maintenance.InterventionIndex("renewal")), "nessun rinnovo nello storico");
|
||||
Assert.True(w.Events.Drain().Any(e => e.Severity == EventSeverity.Warning && e.Text.Contains("rinnovo annullato", StringComparison.Ordinal)),
|
||||
"notizia di avviso");
|
||||
Assert.Equal(0L, w.MoneyBalanceSum());
|
||||
}
|
||||
|
||||
[Test(Description = "La ricostruzione di un modello fuori produzione non lo rende nuovo nel patrimonio")]
|
||||
public static void RebuildKeepsBookAgeOfRetiredModels()
|
||||
{
|
||||
var (f, depot) = ValdoriaIn(1905);
|
||||
var w = f.W;
|
||||
int train = f.Train(depot, "Vecchio", ("loco_steam_1850", 1), ("wagon_hopper", 1));
|
||||
var t = w.Trains[train];
|
||||
w.RunDays(w.Calendar.DaysPerYear + 10);
|
||||
Assert.Equal(1906, w.Clock.Year);
|
||||
var loco = w.Vehicles[t.Vehicles[0].Value];
|
||||
var wagon = w.Vehicles[t.Vehicles[1].Value];
|
||||
long locoBought = loco.BoughtDay;
|
||||
long locoBook = Obsolescence.BookValueCents(w, loco);
|
||||
loco.Components[0] = 10;
|
||||
var replace = w.Data.Maintenance.Interventions[w.Data.Maintenance.InterventionIndex("repair_catastrophic")];
|
||||
Fleet.Apply(w, t, replace, Fleet.PolicyOf(w, t));
|
||||
Assert.Equal(locoBought, loco.BoughtDay, "l'Ardita non si produce più: età contabile invariata");
|
||||
Assert.Equal(locoBook, Obsolescence.BookValueCents(w, loco), "valore di libro invariato");
|
||||
Assert.True(loco.Components.All(c => c == 100), "componenti ricostruiti");
|
||||
Assert.Approx(1, Fleet.AgeFactor(w, loco), 1e-12, "l'usura riparte da capo");
|
||||
Assert.Equal(w.Clock.Day, wagon.BoughtDay, "il carro, ancora in produzione, torna nuovo");
|
||||
}
|
||||
|
||||
[Test(Description = "La Cronaca registra il contenuto di un anno con soli modelli fuori produzione")]
|
||||
public static void MilestoneOfRetirementOnlyYear()
|
||||
{
|
||||
var d = TestData.Data;
|
||||
Assert.Equal(0, EraSystem.Unlocks(d, 1906).Count, "nel 1906 nessuno sblocco");
|
||||
var (f, _) = ValdoriaIn(1878);
|
||||
EraSystem.Announce(f.W, 1906);
|
||||
string text = f.W.Player.Milestones[^1].Text;
|
||||
Assert.True(text.StartsWith("novità del 1906: ", StringComparison.Ordinal) && text.Contains("fuori produzione: Ardita 2-6-0", StringComparison.Ordinal), text);
|
||||
}
|
||||
|
||||
[Test(Description = "Scelte delle IA: carrozze non superate, rinnovi che non peggiorano trazione, potenza, velocità e potenza/massa")]
|
||||
public static void AiChoicesAvoidSupersededAndWeakerModels()
|
||||
{
|
||||
var (f1949, _) = ValdoriaIn(1878);
|
||||
Assert.Equal("coach_worker", Estimators.CoachFor(f1949.W, PaxClass.Worker, 1949)!.Id);
|
||||
Assert.Equal("coach_modern", Estimators.CoachFor(f1949.W, PaxClass.Worker, 1950)!.Id, "dal 1950 la carrozza operai è superata");
|
||||
Assert.Equal("coach_staff", Estimators.CoachFor(f1949.W, PaxClass.Staff, 1950)!.Id, "senza successore resta quella");
|
||||
|
||||
bool Keeps(int year, params (string Type, int Count)[] vehicles)
|
||||
{
|
||||
var (f, depot) = ValdoriaIn(year);
|
||||
var t = f.W.Trains[f.Train(depot, "Prova", vehicles)];
|
||||
var plan = Obsolescence.RenewalPlan(f.W, t);
|
||||
Assert.True(plan.Count > 0, $"{year}: qualcosa da rinnovare");
|
||||
return Obsolescence.KeepsPerformance(f.W, t, plan);
|
||||
}
|
||||
Assert.True(Keeps(1878, ("loco_steam_1850", 1), ("wagon_hopper", 3)), "Ardita → Vittoria migliora tutto");
|
||||
Assert.False(Keeps(1902, ("loco_steam_1878", 1), ("wagon_hopper", 3)), "Vittoria → Freccia perde sforzo di trazione");
|
||||
Assert.True(Keeps(1925, ("loco_steam_1878", 1), ("wagon_hopper", 3)), "dal 1925 la Vittoria passa all'Aquila D1");
|
||||
Assert.False(Keeps(1950, ("loco_diesel_1925", 1), ("coach_worker", 8)), "carrozze più pesanti con la stessa potenza");
|
||||
}
|
||||
|
||||
[Test(Slow = true, Description = "Le IA rinnovano i treni con locomotive superate, senza comandi rifiutati oltre il 5 %")]
|
||||
public static void AiRenewsSupersededTrains()
|
||||
{
|
||||
var files = MemoryDataSource.Snapshot(TestData.Source);
|
||||
var ai = JsonNode.Parse(files["ai.json"])!;
|
||||
ai["renewal"]!["minSupersededYears"] = 0;
|
||||
files["ai.json"] = ai.ToJsonString();
|
||||
var data = GameData.Load(new MemoryDataSource(files));
|
||||
var w = WorldFactory.Create(data, new NewGameSettings { Seed = 42, SizeKm = 64, StartYear = 1875 });
|
||||
// fino al 1878: le IA costruiscono le prime linee con l'Ardita del 1850
|
||||
w.RunTicks((long)3 * w.Calendar.DaysPerYear * w.Calendar.TicksPerDay - w.Clock.Tick);
|
||||
Assert.Equal(1878, w.Clock.Year);
|
||||
var oldTrains = w.Trains
|
||||
.Where(t => !t.Removed && !w.Company(t.Owner).IsPlayer && t.Vehicles.Any(id => w.Vehicles[id.Value].Def.Id == "loco_steam_1850"))
|
||||
.Select(t => t.Id).ToList();
|
||||
Assert.True(oldTrains.Count > 0, "le IA hanno treni con l'Ardita");
|
||||
w.RunYears(2);
|
||||
int renewed = oldTrains.Count(id => w.Trains[id.Value].Vehicles.Any(v => w.Vehicles[v.Value].Def.Id == "loco_steam_1878"));
|
||||
Assert.True(renewed > 0, $"almeno un treno rinnovato su {oldTrains.Count}");
|
||||
foreach (var s in w.AiStates)
|
||||
Assert.True(s.RejectedShare <= w.Data.Ai.Planning.MaxRejectedShare, $"{w.Company(s.Company).Name}: {s.Rejected} rifiutati su {s.Issued}");
|
||||
Assert.Equal(0L, w.MoneyBalanceSum());
|
||||
}
|
||||
}
|
||||
@@ -188,6 +188,22 @@ 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 FleetReport
|
||||
{
|
||||
Day = 10_100, Company = 0, Year = 1878, Era = "steam", NextEra = "diesel", NextEraYear = 1925, RenewalIntervention = "renewal",
|
||||
BookValueTotal = new Money(1_234_567),
|
||||
Vehicles =
|
||||
[
|
||||
new FleetVehicleInfo { Vehicle = 3, Type = "loco_steam_1850", Train = 1, Depot = -1, AgeYears = 26.5f, LifeYears = 25, Condition = 0.8f,
|
||||
InProduction = true, Superseded = true, SupersededYear = 1878, Successor = "loco_steam_1878", BookValue = new Money(180_000),
|
||||
Resale = new Money(144_000), MaintenanceFactor = 1.5f },
|
||||
new FleetVehicleInfo { Vehicle = 4, Type = "wagon_hopper", Train = -1, Depot = 2, AgeYears = 1f, LifeYears = 40, Condition = 1f,
|
||||
InProduction = true, BookValue = new Money(117_000), Resale = new Money(117_000), MaintenanceFactor = 1f },
|
||||
],
|
||||
Models = [new VehicleModelInfo { Type = "loco_steam_1850", Superseded = true, SupersededYear = 1878, Successor = "loco_steam_1878", LastYear = 1905 },
|
||||
new VehicleModelInfo { Type = "wagon_hopper" }],
|
||||
Trains = [new RenewalTrainInfo { Train = 1, Vehicles = 1, NetCost = new Money(3_056_000), Affordable = true, Booked = true }],
|
||||
};
|
||||
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),
|
||||
|
||||
Reference in new issue
Block a user